@corsair-dev/mailsso 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,191 @@
+  Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work 
+      (which shall not include Communications that are clearly marked or
+      otherwise designated in writing by the copyright owner as "Not a Work").
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution".
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright (c) 2026 Corsair
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,33 @@
-# Temporary Holding Version
+# @corsair-dev/mailsso
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Mails.so email validation plugin for Corsair: validate one address or a batch, and read a batch job back. The plugin does not handle webhooks, because Mails.so sends none.
+
+## Install
+
+```bash
+pnpm add @corsair-dev/mailsso
+```
+
+## Endpoints
+
+| Operation | Operation ID | Risk | Description |
+|-----------|--------------|------|-------------|
+| `validations.batch` | `mailsso.api.validations.batch` | `write` | Start a batch validation job for at least 2 different email addresses; needs a paid Mails.so plan, and the job cannot be deleted through the API. It returns the job at once with no results: follow it with validations.getBatch until status is completed (it reads processing meanwhile). |
+| `validations.getBatch` | `mailsso.api.validations.getBatch` | `read` | Read a batch validation job by id: status processing while it runs, and once completed the counts per result and the validation of every address |
+| `validations.single` | `mailsso.api.validations.single` | `read` | Validate one email address: deliverability result and reason, a 0-100 score, and format, domain, MX, block-list, catch-all, generic, disposable and free-provider checks |
+
+## Auth
+
+Auth: API key. Corsair prompts your tenant for credentials on first use.
+
+## Webhooks
+
+No webhooks.
+
+## Reference
+
+Full docs, types, and examples: https://docs.corsair.dev/plugins/mailsso
+
+## License
+
+Apache-2.0

package/dist/api.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=api.test.d.ts.map

package/dist/api.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.test.d.ts","sourceRoot":"","sources":["../api.test.ts"],"names":[],"mappings":""}

package/dist/client.d.ts

@@ -0,0 +1,75 @@
+export declare const MAILSSO_API_BASE = "https://api.mails.so";
+/** An untyped response body: each endpoint's zod output schema gives it a shape. */
+export type MailssoBody = unknown;
+/**
+ * Mails.so answers failures as `{ data: null, error: '<message>' }`, and the
+ * batch routes add `error_code` (for example `BATCH_TOO_SMALL`). A request that
+ * succeeds can still carry a non-null `error`, so a 2xx body is checked too.
+ */
+export declare class MailssoAPIError extends Error {
+    readonly status?: number;
+    /** The provider's `error_code`, when the body carries one. */
+    readonly code?: string;
+    /** Milliseconds from a Retry-After header, when Mails.so sent one. */
+    readonly retryAfter?: number;
+    /** The HTTP method of the failed request. */
+    readonly method?: string;
+    /** True when the request failed before any response arrived. */
+    readonly transport: boolean;
+    constructor(message: string, options?: {
+        cause?: Error;
+        status?: number;
+        code?: string;
+        retryAfter?: number;
+        method?: string;
+        transport?: boolean;
+    });
+    /** True for a 429. */
+    get isRateLimit(): boolean;
+}
+/**
+ * Mails.so documents batch validation as paid-plan only (a free account with
+ * credits ran one in our live test). The documented refusal is
+ * `Paid subscription required to use list validations`, a 401,
+ * so it is told apart from a bad key by its message and never retried.
+ */
+export declare class MailssoSubscriptionRequiredError extends MailssoAPIError {
+    constructor(message: string, options?: ConstructorParameters<typeof MailssoAPIError>[1]);
+}
+export type MailssoQuery = Record<string, string | number | boolean | undefined>;
+export type MailssoRequest = {
+    method: 'GET' | 'POST';
+    path: string;
+    query?: MailssoQuery;
+    body?: Record<string, string[]>;
+    /**
+     * Set on the batch status read only: a running job answers 202 with a
+     * non-null `error` that is not a failure (see readJobInProgress).
+     */
+    allowInProgress?: boolean;
+};
+/**
+ * While a batch job runs, GET /v1/batch/{id} answers HTTP 202 with
+ * `{ data: { id, created_at, status: 'processing' }, error: 'Job is still
+ * processing' }`. That non-null `error` is a progress note, not a failure.
+ *
+ * The exception is limited to that exact note: a real failure can also carry
+ * `data.id` and `status: 'processing'` (for example an error raised while a job
+ * is mid-flight), and treating every message as progress would leave the caller
+ * polling a job that has already failed.
+ */
+export declare const JOB_IN_PROGRESS_MESSAGE = "Job is still processing";
+/**
+ * Reads the job out of the progress note, or `undefined` when the body is
+ * anything else.
+ *
+ * The note has to match exactly (`JOB_IN_PROGRESS_MESSAGE` *and* a job id
+ * *and* `status: 'processing'`): a real failure can carry the same data, and
+ * treating it as progress would leave the caller polling a job that has
+ * already failed.
+ */
+export declare function readJobInProgress(body: MailssoBody): MailssoBody | undefined;
+/** Encodes one path segment. */
+export declare function segment(value: string | number): string;
+export declare function makeMailssoRequest(apiKey: string, { method, path, query, body, allowInProgress }: MailssoRequest): Promise<MailssoBody>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../client.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,gBAAgB,yBAAyB,CAAC;AAevD,oFAAoF;AACpF,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC;AAclC;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,sEAAsE;IACtE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,gEAAgE;IAChE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;gBAG3B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;QACR,KAAK,CAAC,EAAE,KAAK,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,OAAO,CAAC;KACf;IAYP,sBAAsB;IACtB,IAAI,WAAW,IAAI,OAAO,CAEzB;CACD;AAED;;;;;GAKG;AACH,qBAAa,gCAAiC,SAAQ,eAAe;gBAEnE,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,qBAAqB,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,CAAM;CAK/D;AAWD,MAAM,MAAM,YAAY,GAAG,MAAM,CAChC,MAAM,EACN,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CACrC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC5B,MAAM,EAAE,KAAK,GAAG,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAChC;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,4BAA4B,CAAC;AAEjE;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW,GAAG,SAAS,CAQ5E;AAED,gCAAgC;AAChC,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAEtD;AAID,wBAAsB,kBAAkB,CACvC,MAAM,EAAE,MAAM,EACd,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,eAAe,EAAE,EAAE,cAAc,GAC5D,OAAO,CAAC,WAAW,CAAC,CA2DtB"}

package/dist/client.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client.test.d.ts.map

package/dist/client.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.test.d.ts","sourceRoot":"","sources":["../client.test.ts"],"names":[],"mappings":""}

package/dist/endpoints/call.d.ts

@@ -0,0 +1,19 @@
+import type { z } from 'zod';
+import type { MailssoContext } from '..';
+import type { MailssoBody, MailssoRequest } from '../client';
+type LogFields = Record<string, string | number | boolean | undefined>;
+/**
+ * Validates the input, sends the request, shapes and validates the response,
+ * then logs the event. Inputs are not logged, because they hold email
+ * addresses; `log` picks the safe fields.
+ */
+export declare function call<Input extends z.ZodType, Output extends z.ZodType>(ctx: MailssoContext, operation: {
+    event: string;
+    input: Input;
+    output: Output;
+}, rawInput: MailssoBody, toRequest: (parsed: z.output<Input>) => MailssoRequest, options?: {
+    shape?: (raw: MailssoBody) => MailssoBody;
+    log?: (result: z.output<Output>) => LogFields;
+}): Promise<z.output<Output>>;
+export {};
+//# sourceMappingURL=call.d.ts.map

package/dist/endpoints/call.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call.d.ts","sourceRoot":"","sources":["../../endpoints/call.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,IAAI,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAG7D,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,CAAC;AAEvE;;;;GAIG;AACH,wBAAsB,IAAI,CAAC,KAAK,SAAS,CAAC,CAAC,OAAO,EAAE,MAAM,SAAS,CAAC,CAAC,OAAO,EAC3E,GAAG,EAAE,cAAc,EACnB,SAAS,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAC1D,QAAQ,EAAE,WAAW,EACrB,SAAS,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,cAAc,EACtD,OAAO,GAAE;IACR,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,WAAW,CAAC;IAC1C,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,SAAS,CAAC;CACzC,GACJ,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAc3B"}

package/dist/endpoints/index.d.ts

@@ -0,0 +1,4 @@
+import * as Validations from './validations';
+export { Validations };
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/endpoints/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../endpoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,cAAc,SAAS,CAAC"}

package/dist/endpoints/types.d.ts

@@ -0,0 +1,247 @@
+import { z } from 'zod';
+declare const ValidationsSingleInputSchema: z.ZodObject<{
+    email: z.ZodString;
+}, z.core.$strip>;
+export type ValidationsSingleInput = z.input<typeof ValidationsSingleInputSchema>;
+declare const ValidationsBatchInputSchema: z.ZodObject<{
+    emails: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ValidationsBatchInput = z.input<typeof ValidationsBatchInputSchema>;
+declare const ValidationsGetBatchInputSchema: z.ZodObject<{
+    id: z.ZodGUID;
+}, z.core.$strip>;
+export type ValidationsGetBatchInput = z.input<typeof ValidationsGetBatchInputSchema>;
+/**
+ * One validated address. Both validations.single and each entry of a batch's
+ * `emails` use it. `result` and `reason` stay plain strings so a value
+ * Mails.so adds later does not fail a call that already succeeded; the
+ * documented results are deliverable, undeliverable, risky and a fourth for
+ * checks that could not finish.
+ */
+export declare const MailssoEmailValidationSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodString;
+    username: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    domain: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    did_you_mean: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    mx_record: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    isv_format: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    isv_domain: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    isv_mx: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    isv_noblock: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    isv_nocatchall: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    isv_nogeneric: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    is_disposable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    is_free: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    avatar: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    result: z.ZodString;
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export type MailssoEmailValidation = z.output<typeof MailssoEmailValidationSchema>;
+declare const ValidationsBatchOutputSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    archived_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    user_id: z.ZodString;
+    size: z.ZodNumber;
+    progress: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    duration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    duplicates: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    file_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    file_key: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    skip_emails: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$loose>;
+export type ValidationsBatchResponse = z.output<typeof ValidationsBatchOutputSchema>;
+/**
+ * Status values of a batch job, as seen live: `pending` in the answer to the
+ * POST, `processing` while the status read reports it running, and `completed`
+ * once finished. Mails.so documents no failed status, so the job declaration in
+ * index.ts lists none; a stuck job shows as a status that stays running with
+ * `finished_at` still null.
+ */
+export declare const BATCH_STATUSES: {
+    readonly running: readonly ["pending", "processing"];
+    readonly done: readonly ["completed"];
+};
+declare const ValidationsGetBatchOutputSchema: z.ZodObject<{
+    updated_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    user_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    size: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    status: z.ZodString;
+    stats: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>>;
+    emails: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodString;
+        username: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        domain: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        did_you_mean: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        mx_record: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        isv_format: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        isv_domain: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        isv_mx: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        isv_noblock: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        isv_nocatchall: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        isv_nogeneric: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        is_disposable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        is_free: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        avatar: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        result: z.ZodString;
+        reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>>>;
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    created_at: z.ZodString;
+    deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    archived_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    progress: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    duration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    duplicates: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    file_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    file_key: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    skip_emails: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$loose>;
+export type ValidationsGetBatchResponse = z.output<typeof ValidationsGetBatchOutputSchema>;
+export type ValidationsSingleResponse = MailssoEmailValidation;
+/** The `{ data, error }` envelope Mails.so wraps a single validation in. */
+export declare const MailssoSingleEnvelopeSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodString;
+        username: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        domain: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        did_you_mean: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        mx_record: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        isv_format: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        isv_domain: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        isv_mx: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        isv_noblock: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        isv_nocatchall: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        isv_nogeneric: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        is_disposable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        is_free: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        avatar: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        result: z.ZodString;
+        reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>;
+    error: z.ZodOptional<z.ZodNull>;
+}, z.core.$loose>;
+export type MailssoEndpointInputs = {
+    validationsSingle: ValidationsSingleInput;
+    validationsBatch: ValidationsBatchInput;
+    validationsGetBatch: ValidationsGetBatchInput;
+};
+export type MailssoEndpointOutputs = {
+    validationsSingle: ValidationsSingleResponse;
+    validationsBatch: ValidationsBatchResponse;
+    validationsGetBatch: ValidationsGetBatchResponse;
+};
+export declare const MailssoEndpointInputSchemas: {
+    readonly validationsSingle: z.ZodObject<{
+        email: z.ZodString;
+    }, z.core.$strip>;
+    readonly validationsBatch: z.ZodObject<{
+        emails: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    readonly validationsGetBatch: z.ZodObject<{
+        id: z.ZodGUID;
+    }, z.core.$strip>;
+};
+export declare const MailssoEndpointOutputSchemas: {
+    readonly validationsSingle: z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodString;
+        username: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        domain: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        did_you_mean: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        mx_record: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        isv_format: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        isv_domain: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        isv_mx: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        isv_noblock: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        isv_nocatchall: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        isv_nogeneric: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        is_disposable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        is_free: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        avatar: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        result: z.ZodString;
+        reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>;
+    readonly validationsBatch: z.ZodObject<{
+        status: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+        deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        archived_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        user_id: z.ZodString;
+        size: z.ZodNumber;
+        progress: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        duration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        duplicates: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        file_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        file_key: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        skip_emails: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$loose>;
+    readonly validationsGetBatch: z.ZodObject<{
+        updated_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        user_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        size: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        status: z.ZodString;
+        stats: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>>;
+        emails: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            email: z.ZodString;
+            username: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            domain: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            did_you_mean: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            mx_record: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            isv_format: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            isv_domain: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            isv_mx: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            isv_noblock: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            isv_nocatchall: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            isv_nogeneric: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            is_disposable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            is_free: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            avatar: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            result: z.ZodString;
+            reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>>>>;
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        created_at: z.ZodString;
+        deleted_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        archived_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        progress: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        duration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        duplicates: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        file_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        file_key: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        skip_emails: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$loose>;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/endpoints/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../endpoints/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,QAAA,MAAM,4BAA4B;;iBAOhC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,4BAA4B,CACnC,CAAC;AAEF,QAAA,MAAM,2BAA2B;;iBAU/B,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,QAAA,MAAM,8BAA8B;;iBAMlC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,8BAA8B,CACrC,CAAC;AAIF;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;iBA0DhC,CAAC;AAEV,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAC5C,OAAO,4BAA4B,CACnC,CAAC;AA6CF,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;iBAQzB,CAAC;AAEV,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAC9C,OAAO,4BAA4B,CACnC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;CAGjB,CAAC;AAIX,QAAA,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwB5B,CAAC;AAEV,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CACjD,OAAO,+BAA+B,CACtC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,sBAAsB,CAAC;AAE/D,4EAA4E;AAC5E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;iBAK/B,CAAC;AAEV,MAAM,MAAM,qBAAqB,GAAG;IACnC,iBAAiB,EAAE,sBAAsB,CAAC;IAC1C,gBAAgB,EAAE,qBAAqB,CAAC;IACxC,mBAAmB,EAAE,wBAAwB,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACpC,iBAAiB,EAAE,yBAAyB,CAAC;IAC7C,gBAAgB,EAAE,wBAAwB,CAAC;IAC3C,mBAAmB,EAAE,2BAA2B,CAAC;CACjD,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;CAI9B,CAAC;AAEX,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/B,CAAC"}

package/dist/endpoints/validations.d.ts

@@ -0,0 +1,5 @@
+import type { MailssoEndpoints } from '..';
+export declare const single: MailssoEndpoints['validationsSingle'];
+export declare const batch: MailssoEndpoints['validationsBatch'];
+export declare const getBatch: MailssoEndpoints['validationsGetBatch'];
+//# sourceMappingURL=validations.d.ts.map

package/dist/endpoints/validations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validations.d.ts","sourceRoot":"","sources":["../../endpoints/validations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,IAAI,CAAC;AAS3C,eAAO,MAAM,MAAM,EAAE,gBAAgB,CAAC,mBAAmB,CAuBvD,CAAC;AAKH,eAAO,MAAM,KAAK,EAAE,gBAAgB,CAAC,kBAAkB,CAqBrD,CAAC;AAEH,eAAO,MAAM,QAAQ,EAAE,gBAAgB,CAAC,qBAAqB,CAwB3D,CAAC"}

package/dist/endpoints.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=endpoints.test.d.ts.map

package/dist/endpoints.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoints.test.d.ts","sourceRoot":"","sources":["../endpoints.test.ts"],"names":[],"mappings":""}

package/dist/error-handlers.d.ts

@@ -0,0 +1,60 @@
+import type { CorsairErrorHandler } from 'corsair/core';
+import { MailssoSubscriptionRequiredError } from './client';
+export declare const errorHandlers: {
+    SUBSCRIPTION_REQUIRED_ERROR: {
+        match: (error: Error) => error is MailssoSubscriptionRequiredError;
+        handler: () => Promise<{
+            maxRetries: number;
+        }>;
+    };
+    RATE_LIMIT_ERROR: {
+        match: (error: Error) => boolean;
+        handler: (error: Error) => Promise<{
+            maxRetries: number;
+            headersRetryAfterMs: number | undefined;
+            retryStrategy: "exponential_backoff";
+        }>;
+    };
+    AUTH_ERROR: {
+        match: (error: Error) => boolean;
+        handler: () => Promise<{
+            maxRetries: number;
+        }>;
+    };
+    VALIDATION_ERROR: {
+        match: (error: Error) => boolean;
+        handler: () => Promise<{
+            maxRetries: number;
+        }>;
+    };
+    SERVER_ERROR: {
+        match: (error: Error) => boolean;
+        handler: () => Promise<{
+            maxRetries: number;
+            retryStrategy: "exponential_backoff";
+        }>;
+    };
+    NETWORK_ERROR: {
+        match: (error: Error) => boolean;
+        handler: () => Promise<{
+            maxRetries: number;
+            retryStrategy: "exponential_backoff";
+        }>;
+    };
+    DEFAULT: {
+        match: () => true;
+        handler: () => Promise<{
+            maxRetries: number;
+        }>;
+    };
+};
+/**
+ * Merges a caller's handlers over the builtins, keeping `DEFAULT` last.
+ *
+ * Core runs the first handler whose `match` passes, in key order, and `DEFAULT`
+ * matches everything. Caller keys go first so a handler for a status no builtin
+ * covers is reached before `DEFAULT` claims it; a caller `DEFAULT` replaces the
+ * builtin one, and the builtin `DEFAULT` is only used when the caller has none.
+ */
+export declare function mergeErrorHandlers(builtin: CorsairErrorHandler, user: CorsairErrorHandler | undefined): CorsairErrorHandler;
+//# sourceMappingURL=error-handlers.d.ts.map

package/dist/error-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handlers.d.ts","sourceRoot":"","sources":["../error-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAmB,gCAAgC,EAAE,MAAM,UAAU,CAAC;AAU7E,eAAO,MAAM,aAAa;;uBAIT,KAAK;;;;;;uBAML,KAAK;yBAEG,KAAK;;;;;;;uBASb,KAAK;;;;;;uBAML,KAAK;;;;;;uBASL,KAAK;;;;;;;uBAYL,KAAK;;;;;;;;;;;;CAaS,CAAC;AAEhC;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CACjC,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,mBAAmB,GAAG,SAAS,GACnC,mBAAmB,CAWrB"}

package/dist/error-handlers.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=error-handlers.test.d.ts.map

package/dist/error-handlers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handlers.test.d.ts","sourceRoot":"","sources":["../error-handlers.test.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -0,0 +1,132 @@
+import type { BindEndpoints, CorsairEndpoint, CorsairErrorHandler, CorsairPlugin, CorsairPluginContext, KeyBuilderContext, PickAuth, PluginPermissionsConfig } from 'corsair/core';
+import type { MailssoEndpointInputs, MailssoEndpointOutputs } from './endpoints/types';
+import { MailssoSchema } from './schema';
+export type MailssoPluginOptions = {
+    authType?: PickAuth<'api_key'>;
+    key?: string;
+    hooks?: InternalMailssoPlugin['hooks'];
+    errorHandlers?: CorsairErrorHandler;
+    permissions?: PluginPermissionsConfig<typeof mailssoEndpointsNested>;
+};
+export type MailssoContext = CorsairPluginContext<typeof MailssoSchema, MailssoPluginOptions>;
+export type MailssoKeyBuilderContext = KeyBuilderContext<MailssoPluginOptions>;
+export type MailssoBoundEndpoints = BindEndpoints<typeof mailssoEndpointsNested>;
+type MailssoEndpoint<K extends keyof MailssoEndpointOutputs> = CorsairEndpoint<MailssoContext, MailssoEndpointInputs[K], MailssoEndpointOutputs[K]>;
+export type MailssoEndpoints = {
+    validationsSingle: MailssoEndpoint<'validationsSingle'>;
+    validationsBatch: MailssoEndpoint<'validationsBatch'>;
+    validationsGetBatch: MailssoEndpoint<'validationsGetBatch'>;
+};
+declare const mailssoEndpointsNested: {
+    readonly validations: {
+        readonly single: MailssoEndpoint<"validationsSingle">;
+        readonly batch: MailssoEndpoint<"validationsBatch">;
+        readonly getBatch: MailssoEndpoint<"validationsGetBatch">;
+    };
+};
+export declare const mailssoEndpointSchemas: {
+    readonly 'validations.single': {
+        readonly input: import("zod").ZodObject<{
+            email: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            email: import("zod").ZodString;
+            username: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            domain: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            did_you_mean: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            mx_record: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            provider: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            score: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+            isv_format: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+            isv_domain: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+            isv_mx: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+            isv_noblock: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+            isv_nocatchall: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+            isv_nogeneric: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+            is_disposable: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+            is_free: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+            avatar: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            result: import("zod").ZodString;
+            reason: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        }, import("zod/v4/core").$loose>;
+    };
+    readonly 'validations.batch': {
+        readonly input: import("zod").ZodObject<{
+            emails: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            status: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            id: import("zod").ZodString;
+            name: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            created_at: import("zod").ZodString;
+            updated_at: import("zod").ZodString;
+            deleted_at: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            finished_at: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            archived_at: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            user_id: import("zod").ZodString;
+            size: import("zod").ZodNumber;
+            progress: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+            duration: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+            duplicates: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+            type: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            file_type: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            file_key: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            skip_emails: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+        }, import("zod/v4/core").$loose>;
+    };
+    readonly 'validations.getBatch': {
+        readonly input: import("zod").ZodObject<{
+            id: import("zod").ZodGUID;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            updated_at: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            user_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            size: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+            status: import("zod").ZodString;
+            stats: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>>>;
+            emails: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                email: import("zod").ZodString;
+                username: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                domain: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                did_you_mean: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                mx_record: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                provider: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                score: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+                isv_format: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+                isv_domain: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+                isv_mx: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+                isv_noblock: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+                isv_nocatchall: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+                isv_nogeneric: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+                is_disposable: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+                is_free: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+                avatar: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                result: import("zod").ZodString;
+                reason: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            }, import("zod/v4/core").$loose>>>>;
+            id: import("zod").ZodString;
+            name: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            created_at: import("zod").ZodString;
+            deleted_at: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            finished_at: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            archived_at: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            progress: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+            duration: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+            duplicates: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+            type: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            file_type: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            file_key: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            skip_emails: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+        }, import("zod/v4/core").$loose>;
+    };
+};
+declare const defaultAuthType: "api_key";
+export type BaseMailssoPlugin<T extends MailssoPluginOptions> = CorsairPlugin<'mailsso', typeof MailssoSchema, typeof mailssoEndpointsNested, {}, T, typeof defaultAuthType>;
+export type InternalMailssoPlugin = BaseMailssoPlugin<MailssoPluginOptions>;
+export type ExternalMailssoPlugin<T extends MailssoPluginOptions> = BaseMailssoPlugin<T>;
+export declare function mailsso<const T extends MailssoPluginOptions>(incomingOptions?: MailssoPluginOptions & T): ExternalMailssoPlugin<T>;
+export { MailssoAPIError, MailssoSubscriptionRequiredError, } from './client';
+export type { MailssoEmailValidation, MailssoEndpointInputs, MailssoEndpointOutputs, ValidationsBatchInput, ValidationsBatchResponse, ValidationsGetBatchInput, ValidationsGetBatchResponse, ValidationsSingleInput, ValidationsSingleResponse, } from './endpoints/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,QAAQ,EACR,uBAAuB,EAGvB,MAAM,cAAc,CAAC;AAGtB,OAAO,KAAK,EACX,qBAAqB,EACrB,sBAAsB,EACtB,MAAM,mBAAmB,CAAC;AAO3B,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,MAAM,MAAM,oBAAoB,GAAG;IAClC,QAAQ,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,qBAAqB,CAAC,OAAO,CAAC,CAAC;IACvC,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC,WAAW,CAAC,EAAE,uBAAuB,CAAC,OAAO,sBAAsB,CAAC,CAAC;CACrE,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,oBAAoB,CAChD,OAAO,aAAa,EACpB,oBAAoB,CACpB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,iBAAiB,CAAC,oBAAoB,CAAC,CAAC;AAE/E,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAChD,OAAO,sBAAsB,CAC7B,CAAC;AAEF,KAAK,eAAe,CAAC,CAAC,SAAS,MAAM,sBAAsB,IAAI,eAAe,CAC7E,cAAc,EACd,qBAAqB,CAAC,CAAC,CAAC,EACxB,sBAAsB,CAAC,CAAC,CAAC,CACzB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC9B,iBAAiB,EAAE,eAAe,CAAC,mBAAmB,CAAC,CAAC;IACxD,gBAAgB,EAAE,eAAe,CAAC,kBAAkB,CAAC,CAAC;IACtD,mBAAmB,EAAE,eAAe,CAAC,qBAAqB,CAAC,CAAC;CAC5D,CAAC;AAEF,QAAA,MAAM,sBAAsB;;;;;;CAMlB,CAAC;AAEX,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAelC,CAAC;AAEF,QAAA,MAAM,eAAe,EAAG,SAAkB,CAAC;AAqC3C,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,oBAAoB,IAAI,aAAa,CAC5E,SAAS,EACT,OAAO,aAAa,EACpB,OAAO,sBAAsB,EAC7B,EAAE,EACF,CAAC,EACD,OAAO,eAAe,CACtB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,CAAC,oBAAoB,CAAC,CAAC;AAE5E,MAAM,MAAM,qBAAqB,CAAC,CAAC,SAAS,oBAAoB,IAC/D,iBAAiB,CAAC,CAAC,CAAC,CAAC;AAEtB,wBAAgB,OAAO,CAAC,KAAK,CAAC,CAAC,SAAS,oBAAoB,EAC3D,eAAe,GAAE,oBAAoB,GAAG,CAAkC,GACxE,qBAAqB,CAAC,CAAC,CAAC,CA6B1B;AAED,OAAO,EACN,eAAe,EACf,gCAAgC,GAChC,MAAM,UAAU,CAAC;AAElB,YAAY,EACX,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,wBAAwB,EACxB,wBAAwB,EACxB,2BAA2B,EAC3B,sBAAsB,EACtB,yBAAyB,GACzB,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+var k=Object.defineProperty;var C=(e,i)=>{for(var s in i)k(e,s,{get:i[s],enumerable:!0})};import{AuthMissingError as $}from"corsair/core";var m={};C(m,{batch:()=>W,getBatch:()=>J,single:()=>K});import{asRecord as M}from"corsair/core";import{ApiError as B,request as V}from"corsair/http";var j="https://api.mails.so",G={maxRetries:0,enabled:!0,initialRetryDelay:1e3,backoffMultiplier:2,headerNames:{retryAfter:"retry-after"}},H=/paid subscription/i;function g(e,i){let s=M(e)?.[i];return typeof s=="string"&&s.length>0?s:void 0}var n=class extends Error{status;code;retryAfter;method;transport;constructor(i,s={}){super(i,s.cause?{cause:s.cause}:void 0),this.name="MailssoAPIError";let a=s.cause instanceof B?s.cause:void 0;this.status=s.status??a?.status,this.code=s.code??g(a?.body,"error_code"),this.retryAfter=s.retryAfter??a?.retryAfter,this.method=s.method??a?.request.method,this.transport=s.transport??!1}get isRateLimit(){return this.status===429}},h=class extends n{constructor(i,s={}){super(i,s),this.name="MailssoSubscriptionRequiredError"}};function x(e,i){return H.test(e)?new h(e,i):new n(e,i)}var L="Job is still processing";function v(e){let i=M(e),s=M(i?.data);if(g(i,"error")===L)return typeof s?.id=="string"&&s.status==="processing"?s:void 0}function R(e){return encodeURIComponent(String(e))}async function I(e,{method:i,path:s,query:a,body:o,allowInProgress:f}){let r={BASE:j,VERSION:"1.0.0",WITH_CREDENTIALS:!1,CREDENTIALS:"omit",HEADERS:{Accept:"application/json","x-mails-api-key":e}},u={method:i,url:s,query:a,body:o,mediaType:o===void 0?void 0:"application/json"},d;try{d=await V(r,u,{rateLimitConfig:G})}catch(l){throw l instanceof B?x(g(l.body,"error")??`Mails.so ${l.status}: ${l.message}`,{cause:l}):l instanceof Error||l instanceof DOMException?new n(l.message,{cause:l,method:i,transport:!0}):new n("Unknown Mails.so error",{method:i,transport:!0})}let y=g(d,"error");if(y!==void 0&&!(f&&v(d)!==void 0))throw x(y,{status:200,method:i,code:g(d,"error_code")});return d}import{logEventFromContext as N}from"corsair/core";async function E(e,i,s,a,o={}){let f=i.input.parse(s),r=await I(e.key,a(f)),u=i.output.parse(o.shape?o.shape(r):r);return await N(e,`mailsso.${i.event}`,o.log?.(u)??{},"completed"),u}import{z as t}from"zod";var q=t.object({email:t.string().min(1).describe("The email address to validate. A malformed address is not an error: Mails.so answers it as undeliverable with reason invalid_format.")}),z=t.object({emails:t.array(t.string().min(1)).min(2).refine(e=>new Set(e).size>=2,{message:"A batch needs at least 2 different emails"}).describe("The addresses to validate. Mails.so refuses a batch with fewer than 2 different addresses (use validations.single for one).")}),D=t.object({id:t.guid().describe("The batch job id returned by validations.batch, for example 3aace594-f454-42e4-9cb3-198b6253320c.")}),S=t.object({id:t.string().describe("Id of the validation"),email:t.string().describe("The address that was validated"),username:t.string().nullish().describe("The part of the address before the @"),domain:t.string().nullish().describe("The part of the address after the @"),did_you_mean:t.string().nullish().describe("A suggested correction when the domain looks misspelled"),mx_record:t.string().nullish().describe("Mail server of the domain"),provider:t.string().nullish().describe("Mailbox provider, for example google_workspace"),score:t.number().nullish().describe("Overall validity score, 0 to 100"),isv_format:t.boolean().nullish().describe("The format is valid"),isv_domain:t.boolean().nullish().describe("The domain is valid"),isv_mx:t.boolean().nullish().describe("The MX record is valid; null when it was not checked"),isv_noblock:t.boolean().nullish().describe("Not on a block list"),isv_nocatchall:t.boolean().nullish().describe("The domain does not accept every address (not catch-all)"),isv_nogeneric:t.boolean().nullish().describe("Not a generic role address such as info@ or admin@"),is_disposable:t.boolean().nullish().describe("The address belongs to a disposable email service"),is_free:t.boolean().nullish().describe("The address belongs to a free email provider"),avatar:t.string().nullish().describe("Avatar URL, when one was found"),result:t.string().describe("Overall verdict: deliverable, undeliverable, risky, or a fourth value for checks that could not finish"),reason:t.string().nullish().describe("Why Mails.so reached that verdict, for example accepted_email, invalid_domain, invalid_format or catch_all")}).loose(),b={id:t.string().describe("Id of the batch job"),name:t.string().nullish().describe("Name of the batch job, often empty"),created_at:t.string().describe("When the job was created, ISO 8601"),updated_at:t.string().describe("When the job last changed, ISO 8601"),deleted_at:t.string().nullish().describe("When the job was deleted, if it was"),finished_at:t.string().nullish().describe("When the job finished; null while it is still running"),archived_at:t.string().nullish().describe("When the job was archived, if it was"),user_id:t.string().describe("Id of the account that started the job"),size:t.number().describe("Number of addresses in the batch"),progress:t.number().nullish().describe("Progress counter reported by Mails.so"),duration:t.number().nullish().describe("How long the job took"),duplicates:t.number().nullish().describe("Number of duplicate addresses"),type:t.string().nullish().describe("Kind of job; list for a batch"),file_type:t.string().nullish().describe("Set by Mails.so; empty on batches started with this plugin"),file_key:t.string().nullish().describe("Set by Mails.so; empty on batches started with this plugin"),skip_emails:t.boolean().nullish().describe("Set by Mails.so; true on batches started with this plugin")},U=t.object({...b,status:t.string().nullish().describe("Job status; pending right after the job is created")}).loose(),_={running:["pending","processing"],done:["completed"]},F=t.object({...b,updated_at:b.updated_at.nullish(),user_id:b.user_id.nullish(),size:b.size.nullish(),status:t.string().describe("Job status: processing while running, completed when finished"),stats:t.record(t.string(),t.number()).nullish().describe("Counts for a finished job: the total, one per verdict, and one per reason"),emails:t.array(S).nullish().describe("One validation result per address; present on completed jobs, so treat it as absent while the job is processing")}).loose(),T=t.object({data:S,error:t.null().optional()}).loose(),c={validationsSingle:q,validationsBatch:z,validationsGetBatch:D},p={validationsSingle:S,validationsBatch:U,validationsGetBatch:F};var K=(e,i)=>E(e,{event:"validations.single",input:c.validationsSingle,output:p.validationsSingle},i,({email:s})=>({method:"GET",path:"/v1/validate",query:{email:s}}),{shape:s=>T.parse(s).data,log:({result:s,reason:a,score:o})=>({result:s,reason:a??void 0,score:o??void 0})}),W=(e,i)=>E(e,{event:"validations.batch",input:c.validationsBatch,output:p.validationsBatch},i,({emails:s})=>({method:"POST",path:"/v1/batch",body:{emails:s}}),{log:({id:s,size:a,status:o})=>({batchId:s,size:a,status:o??void 0})}),J=(e,i)=>E(e,{event:"validations.getBatch",input:c.validationsGetBatch,output:p.validationsGetBatch},i,({id:s})=>({method:"GET",path:`/v1/batch/${R(s)}`,allowInProgress:!0}),{shape:s=>v(s)??s,log:({id:s,status:a,size:o})=>({batchId:s,status:a,size:o??void 0})});function O(e){return e instanceof n?e.status:void 0}var P={SUBSCRIPTION_REQUIRED_ERROR:{match:e=>e instanceof h,handler:async()=>({maxRetries:0})},RATE_LIMIT_ERROR:{match:e=>e instanceof n&&e.isRateLimit,handler:async e=>({maxRetries:3,headersRetryAfterMs:e instanceof n?e.retryAfter:void 0,retryStrategy:"exponential_backoff"})},AUTH_ERROR:{match:e=>O(e)===401,handler:async()=>({maxRetries:0})},VALIDATION_ERROR:{match:e=>{let i=O(e);return e.name==="ZodError"||i===400||i===404},handler:async()=>({maxRetries:0})},SERVER_ERROR:{match:e=>e instanceof n&&e.method==="GET"&&(e.status??0)>=500,handler:async()=>({maxRetries:2,retryStrategy:"exponential_backoff"})},NETWORK_ERROR:{match:e=>e instanceof n&&e.transport&&e.method==="GET",handler:async()=>({maxRetries:2,retryStrategy:"exponential_backoff"})},DEFAULT:{match:()=>!0,handler:async()=>({maxRetries:0})}};function A(e,i){if(!i)return e;let{DEFAULT:s,...a}=i,{DEFAULT:o,...f}=e,r={...a};for(let[d,y]of Object.entries(f))d in r||(r[d]=y);let u=s??o;return u&&(r.DEFAULT=u),r}var w={version:"1.0.0",entities:{}};var Q={validations:{single:m.single,batch:m.batch,getBatch:m.getBatch}},Z={"validations.single":{input:c.validationsSingle,output:p.validationsSingle},"validations.batch":{input:c.validationsBatch,output:p.validationsBatch},"validations.getBatch":{input:c.validationsGetBatch,output:p.validationsGetBatch}},X="api_key",Y={idPath:"id",status:{op:"validations.getBatch",idArg:"id",statusPath:"status",done:_.done,failed:[]}},ee={"validations.single":{riskLevel:"read",description:"Validate one email address: deliverability result and reason, a 0-100 score, and format, domain, MX, block-list, catch-all, generic, disposable and free-provider checks"},"validations.batch":{riskLevel:"write",description:"Start a batch validation job for at least 2 different email addresses; Mails.so documents it as paid-plan only, but a free account with credits ran batches in our test, and an account without access gets MailssoSubscriptionRequiredError. The job cannot be deleted through the API. It returns the job at once with no results: follow it with validations.getBatch until status is completed (it reads processing meanwhile).",job:Y},"validations.getBatch":{riskLevel:"read",description:"Read a batch validation job by id: status processing while it runs, and once completed the counts per result and the validation of every address"}};function xe(e={}){let i={...e,authType:e.authType??X};return{id:"mailsso",schema:w,options:i,hooks:i.hooks,endpoints:Q,webhooks:{},endpointMeta:ee,endpointSchemas:Z,pluginWebhookMatcher:()=>!1,errorHandlers:A(P,i.errorHandlers),keyBuilder:async(s,a)=>{if(a==="endpoint"&&i.key)return i.key;if(a==="endpoint"&&s.authType==="api_key"){let o=await s.keys.get_api_key();if(o)return o}throw new $("mailsso",s.authType??"api_key")}}}export{n as MailssoAPIError,h as MailssoSubscriptionRequiredError,xe as mailsso,Z as mailssoEndpointSchemas};

package/dist/jobs.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jobs.test.d.ts.map

package/dist/jobs.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jobs.test.d.ts","sourceRoot":"","sources":["../jobs.test.ts"],"names":[],"mappings":""}

package/dist/plugin.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=plugin.test.d.ts.map

package/dist/plugin.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.test.d.ts","sourceRoot":"","sources":["../plugin.test.ts"],"names":[],"mappings":""}

package/dist/requests.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=requests.test.d.ts.map

package/dist/requests.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requests.test.d.ts","sourceRoot":"","sources":["../requests.test.ts"],"names":[],"mappings":""}

package/dist/retry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=retry.test.d.ts.map

package/dist/retry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.test.d.ts","sourceRoot":"","sources":["../retry.test.ts"],"names":[],"mappings":""}

package/dist/schema/index.d.ts

@@ -0,0 +1,5 @@
+export declare const MailssoSchema: {
+    readonly version: "1.0.0";
+    readonly entities: {};
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../schema/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;;CAGhB,CAAC"}

package/dist/schema.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schema.test.d.ts.map

package/dist/schema.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.test.d.ts","sourceRoot":"","sources":["../schema.test.ts"],"names":[],"mappings":""}

package/dist/test-fixtures.d.ts

@@ -0,0 +1,199 @@
+/** GET /v1/validate?email=test@example.com */
+export declare const singleUndeliverableFixture: {
+    data: {
+        id: string;
+        email: string;
+        username: string;
+        domain: string;
+        did_you_mean: null;
+        mx_record: null;
+        provider: null;
+        score: number;
+        isv_format: boolean;
+        isv_domain: boolean;
+        isv_mx: boolean;
+        isv_noblock: boolean;
+        isv_nocatchall: boolean;
+        isv_nogeneric: boolean;
+        is_disposable: boolean;
+        is_free: boolean;
+        avatar: null;
+        result: string;
+        reason: string;
+    };
+    error: null;
+};
+/** GET /v1/validate?email=hello@mails.so */
+export declare const singleRiskyFixture: {
+    data: {
+        id: string;
+        email: string;
+        username: string;
+        domain: string;
+        did_you_mean: string;
+        mx_record: string;
+        provider: string;
+        score: number;
+        isv_format: boolean;
+        isv_domain: boolean;
+        isv_mx: boolean;
+        isv_noblock: boolean;
+        isv_nocatchall: boolean;
+        isv_nogeneric: boolean;
+        is_disposable: boolean;
+        is_free: boolean;
+        avatar: null;
+        result: string;
+        reason: string;
+    };
+    error: null;
+};
+/** GET /v1/validate?email=notanemail: 200, not an error. */
+export declare const singleInvalidFormatFixture: {
+    data: {
+        id: string;
+        email: string;
+        username: null;
+        domain: null;
+        did_you_mean: null;
+        mx_record: null;
+        provider: null;
+        score: number;
+        isv_format: boolean;
+        isv_domain: boolean;
+        isv_mx: boolean;
+        isv_noblock: boolean;
+        isv_nocatchall: boolean;
+        isv_nogeneric: boolean;
+        is_disposable: boolean;
+        is_free: boolean;
+        avatar: null;
+        result: string;
+        reason: string;
+    };
+    error: null;
+};
+export declare const batchJobId = "d50cc2f6-2c0a-4742-a0fa-f764240d5f77";
+/** POST /v1/batch with two emails: a bare job object, no envelope. */
+export declare const batchCreatedFixture: {
+    id: string;
+    name: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at: null;
+    finished_at: null;
+    archived_at: null;
+    user: null;
+    user_id: string;
+    size: number;
+    progress: number;
+    status: string;
+    duration: null;
+    duplicates: number;
+    type: string;
+    file_type: string;
+    file_key: string;
+    skip_emails: boolean;
+};
+/** GET /v1/batch/{id} a second after the POST above. */
+export declare const batchCompletedFixture: {
+    id: string;
+    name: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at: null;
+    finished_at: string;
+    archived_at: null;
+    user: null;
+    user_id: string;
+    size: number;
+    progress: number;
+    status: string;
+    duration: number;
+    duplicates: number;
+    type: string;
+    file_type: string;
+    file_key: string;
+    skip_emails: boolean;
+    stats: {
+        total: number;
+        deliverable: number;
+        undeliverable: number;
+        risky: number;
+        unknown: number;
+        invalid_format: number;
+        invalid_domain: number;
+        invalid_smtp: number;
+        rejected_email: number;
+        catch_all: number;
+        disposable: number;
+        timeout: number;
+        no_connect: number;
+        other: number;
+    };
+    emails: {
+        id: string;
+        email: string;
+        username: string;
+        domain: string;
+        did_you_mean: null;
+        mx_record: null;
+        provider: null;
+        score: number;
+        isv_format: boolean;
+        isv_domain: boolean;
+        isv_mx: boolean;
+        isv_noblock: boolean;
+        isv_nocatchall: boolean;
+        isv_nogeneric: boolean;
+        is_disposable: boolean;
+        is_free: boolean;
+        avatar: null;
+        result: string;
+        reason: string;
+    }[];
+};
+/** 401 on GET /v1/validate, with a missing or wrong key. */
+export declare const unauthorizedBody: {
+    data: null;
+    error: string;
+};
+/** 400 on POST /v1/batch with one email, or the same email twice. */
+export declare const batchTooSmallBody: {
+    data: null;
+    error: string;
+    error_code: string;
+};
+/** 400 on POST /v1/batch with `emails` that is not an array. */
+export declare const invalidBodyBody: {
+    data: null;
+    error: string;
+};
+/** 404 on GET /v1/batch/{id} for an id that is a UUID but not a job. */
+export declare const jobMissingBody: {
+    data: null;
+    error: string;
+};
+/** 400 on GET /v1/batch/{id} for an id that is not a UUID. */
+export declare const invalidJobIdBody: {
+    data: null;
+    error: string;
+};
+/** The plan error the docs show on POST /v1/batch for a free key. */
+export declare const subscriptionRequiredBody: {
+    data: null;
+    error: string;
+};
+/**
+ * GET /v1/batch/{id} while the job runs: HTTP 202, and a non-null `error` that
+ * is a progress note, not a failure. The docs do not mention it.
+ */
+export declare const batchProcessingFixture: {
+    data: {
+        created_at: string;
+        id: string;
+        status: string;
+    };
+    error: string;
+};
+//# sourceMappingURL=test-fixtures.d.ts.map

package/dist/test-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-fixtures.d.ts","sourceRoot":"","sources":["../test-fixtures.ts"],"names":[],"mappings":"AAKA,8CAA8C;AAC9C,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;CAuBtC,CAAC;AAEF,4CAA4C;AAC5C,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;CAuB9B,CAAC;AAEF,4DAA4D;AAC5D,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;CAuBtC,CAAC;AAEF,eAAO,MAAM,UAAU,yCAAyC,CAAC;AAEjE,sEAAsE;AACtE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;CAmB/B,CAAC;AAEF,wDAAwD;AACxD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+EjC,CAAC;AAIF,4DAA4D;AAC5D,eAAO,MAAM,gBAAgB;;;CAAwC,CAAC;AAEtE,qEAAqE;AACrE,eAAO,MAAM,iBAAiB;;;;CAK7B,CAAC;AAEF,gEAAgE;AAChE,eAAO,MAAM,eAAe;;;CAG3B,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,cAAc;;;CAAkD,CAAC;AAE9E,8DAA8D;AAC9D,eAAO,MAAM,gBAAgB;;;CAA0C,CAAC;AAExE,qEAAqE;AACrE,eAAO,MAAM,wBAAwB;;;CAGpC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;CAOlC,CAAC"}

package/dist/test-helpers.d.ts

@@ -0,0 +1,17 @@
+import type { MailssoContext } from './index';
+export declare const API_KEY = "mails-secret-test-key";
+/** Any JSON value, so a test body needs no loose type. */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare function jsonResponse(body: JsonValue, status?: number, headers?: Record<string, string>): Response;
+/** What a rejected promise carries. */
+export type Caught = unknown;
+export declare function captureError<T>(promise: Promise<T>): Promise<Caught>;
+/**
+ * A context with the two members the endpoints read: `key`, and
+ * `$getAccountId` for the event log (the log writer tolerates a missing
+ * database). retry.test.ts runs the same endpoints through createCorsair.
+ */
+export declare function makeContext(key?: string): MailssoContext;
+//# sourceMappingURL=test-helpers.d.ts.map

package/dist/test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,eAAO,MAAM,OAAO,0BAA0B,CAAC;AAE/C,0DAA0D;AAC1D,MAAM,MAAM,SAAS,GAClB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,EAAE,GACX;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAEhC,wBAAgB,YAAY,CAC3B,IAAI,EAAE,SAAS,EACf,MAAM,SAAM,EACZ,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GAClC,QAAQ,CAKV;AAED,uCAAuC;AACvC,MAAM,MAAM,MAAM,GAAG,OAAO,CAAC;AAE7B,wBAAsB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAK1E;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,SAAU,GAAG,cAAc,CAMzD"}

package/dist/tsup.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("tsup").Options | import("tsup").Options[] | ((overrideOptions: import("tsup").Options) => import("tsup").Options | import("tsup").Options[] | Promise<import("tsup").Options | import("tsup").Options[]>);
+export default _default;
+//# sourceMappingURL=tsup.config.d.ts.map

package/dist/tsup.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsup.config.d.ts","sourceRoot":"","sources":["../tsup.config.ts"],"names":[],"mappings":";AAEA,wBAYG"}

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@corsair-dev/mailsso",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Mails.so email validation plugin for Corsair: validate one address or a batch, and read a batch job back. The plugin does not handle webhooks, because Mails.so sends none.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "dev-source": "./index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "peerDependencies": {
+    "corsair": ">=0.1.158",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.9",
+    "tsup": "^8.0.1",
+    "typescript": "^5.9.3",
+    "zod": "^4.1.13",
+    "corsair": "0.1.169"
+  },
+  "keywords": [
+    "corsair",
+    "mailsso",
+    "mails.so",
+    "email validation",
+    "plugin"
+  ],
+  "author": "Corsair (https://corsair.dev)",
+  "license": "Apache-2.0",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/corsairdev/corsair.git",
+    "directory": "packages/mailsso"
+  },
+  "homepage": "https://docs.corsair.dev/plugins/mailsso",
+  "scripts": {
+    "build": "rm -rf dist && tsc --build --force && tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "jest",
+    "test:live": "jest --testPathIgnorePatterns=/node_modules/ --testPathPattern=api\\.test\\.ts"
+  }
 }