@corsair-dev/kickbox 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,32 @@
-# Temporary Holding Version
+# @corsair-dev/kickbox
 
-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.
+Kickbox plugin for Corsair: verify a single email address for deliverability, role, free and disposable flags, typo suggestions and a Sendex quality score, and check whether a domain is a known disposable one.
+
+## Install
+
+```bash
+pnpm add @corsair-dev/kickbox
+```
+
+## Endpoints
+
+| Operation | Operation ID | Risk | Description |
+|-----------|--------------|------|-------------|
+| `verify.disposable` | `kickbox.api.verify.disposable` | `read` | Check whether an address or domain is a known disposable one. Free, and answered by Kickbox’s open service |
+| `verify.verify` | `kickbox.api.verify.verify` | `read` | Verify one address and get its verdict (deliverable, undeliverable, risky, unknown), the reason, role and free flags, a typo suggestion and a Sendex quality score. Spends one verification credit |
+
+## 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/kickbox
+
+## 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,100 @@
+/**
+ * Two hosts, because the disposable check is a different service:
+ *
+ * - `api.kickbox.com/v2/verify` takes the key and verifies one address.
+ * - `open.kickbox.com/v1/disposable/:address` is free and keyless, which is why
+ *   it is on its own host.
+ *
+ * An EU-only account is served from `api.eu.kickbox.com`, so the host is a
+ * plugin option rather than a constant.
+ */
+export declare const KICKBOX_API_BASE = "https://api.kickbox.com";
+export declare const KICKBOX_EU_API_BASE = "https://api.eu.kickbox.com";
+export declare const KICKBOX_OPEN_BASE = "https://open.kickbox.com";
+/** The free disposable check's path on the open host. */
+export declare const KICKBOX_DISPOSABLE_PATH = "/v1/disposable/";
+/**
+ * Kickbox answers a failure with the same envelope as a success:
+ * `{ success: false, code, message }`, where `code` is an upper-case string
+ * such as `FORBIDDEN` rather than a status. A spent balance has no code.
+ */
+export declare function readFailure(body: unknown): {
+    success?: boolean;
+    code?: string;
+    message?: string;
+};
+/**
+ * A Kickbox failure that is not an HTTP error: a `200` with
+ * `{ success: false }`, or a request that got no answer.
+ *
+ * Kickbox answers `200` with `{ success: false }` for a refused key or a spent
+ * balance, so a caller that trusted the status alone would read a failure as a
+ * verification result with every field missing. The client throws on that
+ * body instead.
+ *
+ * An HTTP error stays core's `ApiError` (see `sanitizeApiError`).
+ */
+export declare class KickboxAPIError extends Error {
+    readonly status?: number;
+    /** Kickbox's own code, such as `FORBIDDEN` or `INSUFFICIENT_BALANCE`. */
+    readonly code?: string;
+    /** Milliseconds from a Retry-After header, when Kickbox sent one. */
+    readonly retryAfter?: number;
+    /** The HTTP method of the failed request. */
+    readonly method?: string;
+    readonly transport: boolean;
+    readonly timedOut: boolean;
+    /**
+     * True when the request went to the paid verification host. A dropped or
+     * timed-out paid request may still have been charged, so it is not replayed.
+     */
+    readonly paid: boolean;
+    constructor(message: string, options?: {
+        cause?: Error;
+        status?: number;
+        code?: string;
+        retryAfter?: number;
+        method?: string;
+        transport?: boolean;
+        timedOut?: boolean;
+        paid?: boolean;
+    });
+    get isRateLimit(): boolean;
+    /** A refused or missing key. A spent balance is also a 403, but not this. */
+    get isAuthError(): boolean;
+    /** The account has run out of verification credits, which no retry fixes. */
+    get isQuotaError(): boolean;
+    /** The address or domain was refused before any lookup. */
+    get isValidationError(): boolean;
+}
+/**
+ * The status and Kickbox's code on an error of either kind, for handlers and
+ * callers.
+ */
+export declare function kickboxErrorStatus(error: unknown): number | undefined;
+export declare function kickboxErrorCode(error: unknown): string | undefined;
+/** The account has run out of verification credits, which no retry fixes. */
+export declare function isKickboxQuotaError(error: unknown): boolean;
+/** A refused or missing key. A spent balance is also a 403, but not this. */
+export declare function isKickboxAuthError(error: unknown): boolean;
+/**
+ * True when the request went to the paid verification host. A paid request
+ * that failed may still have been charged, so it is never replayed.
+ */
+export declare function isPaidKickboxRequest(error: unknown): boolean;
+/** The message Kickbox sent, with its code in front. */
+export declare function describeKickboxError(status: number | undefined, body: unknown, fallback: string): string;
+export type KickboxQueryValue = string | number | boolean;
+export type KickboxRequest = {
+    method: 'GET';
+    /** The base to send to, which differs between the keyed and open services. */
+    base: string;
+    path: string;
+    query?: Record<string, KickboxQueryValue | undefined>;
+};
+/** Encodes one path segment. */
+export declare function segment(value: string): string;
+export declare function makeKickboxRequest(apiKey: string, { method, base, path, query }: KickboxRequest): Promise<unknown>;
+/** Drops the keys whose value is undefined, so a query carries only what was asked for. */
+export declare function definedQuery(query: Record<string, KickboxQueryValue | undefined>): Record<string, KickboxQueryValue>;
+//# 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;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,4BAA4B,CAAC;AAC1D,eAAO,MAAM,mBAAmB,+BAA+B,CAAC;AAChE,eAAO,MAAM,iBAAiB,6BAA6B,CAAC;AAC5D,yDAAyD;AACzD,eAAO,MAAM,uBAAuB,oBAAoB,CAAC;AAQzD;;;;GAIG;AAEH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG;IAC3C,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB,CAqBA;AAYD;;;;;;;;;;GAUG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,yEAAyE;IACzE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;gBAGtB,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;QACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,IAAI,CAAC,EAAE,OAAO,CAAC;KACV;IAaP,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,6EAA6E;IAC7E,IAAI,WAAW,IAAI,OAAO,CAKzB;IAED,6EAA6E;IAC7E,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED,2DAA2D;IAC3D,IAAI,iBAAiB,IAAI,OAAO,CAE/B;CACD;AAED;;;GAGG;AAEH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAKrE;AAGD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAInE;AAED,6EAA6E;AAE7E,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE3D;AAED,6EAA6E;AAE7E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAM1D;AAED;;;GAGG;AAEH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAQ5D;AA0DD,wDAAwD;AAGxD,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,IAAI,EAAE,OAAO,EACb,QAAQ,EAAE,MAAM,GACd,MAAM,CAOR;AAED,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE1D,MAAM,MAAM,cAAc,GAAG;IAC5B,MAAM,EAAE,KAAK,CAAC;IACd,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAC,CAAC;CACtD,CAAC;AAEF,gCAAgC;AAChC,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE7C;AAGD,wBAAsB,kBAAkB,CACvC,MAAM,EAAE,MAAM,EACd,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,cAAc,GAC3C,OAAO,CAAC,OAAO,CAAC,CAsDlB;AAED,2FAA2F;AAC3F,wBAAgB,YAAY,CAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAC,GAClD,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAMnC"}

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,35 @@
+import type { z } from 'zod';
+import type { KickboxContext } from '..';
+import type { KickboxRequest } 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.
+ *
+ * An address is personal data, so the log carries the domain and the result but
+ * never the address itself.
+ */
+export declare function call<Input extends z.ZodType, Output extends z.ZodType>(ctx: KickboxContext, operation: {
+    event: string;
+    input: Input;
+    output: Output;
+}, rawInput: unknown, toRequest: (parsed: z.output<Input>) => KickboxRequest, options?: {
+    shape?: (raw: unknown, parsed: z.output<Input>) => unknown;
+    log?: (parsed: z.output<Input>, result: z.output<Output>) => LogFields;
+}): Promise<z.output<Output>>;
+/**
+ * The domain half of an address, for a log line that omits the local part. A
+ * bare domain, which `verify.disposable` accepts, is already the domain.
+ * Anything that is not a hostname gives undefined, so text a caller passed by
+ * mistake (a name, a local part) never reaches the event log.
+ */
+export declare function domainOf(address: string): string | undefined;
+/**
+ * The disposable check is free and keyless, but a key is still required to
+ * reach an endpoint at all: `core/endpoints/bind.ts` resolves the account key
+ * before it invokes anything, so an operation cannot run without one. The open
+ * host is used so no credit is spent and the key never travels to it.
+ */
+export declare const OPEN_BASE = "https://open.kickbox.com";
+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,cAAc,EAAE,MAAM,WAAW,CAAC;AAGhD,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,CAAC;AAEvE;;;;;;GAMG;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,EAE1D,QAAQ,EAAE,OAAO,EACjB,SAAS,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,cAAc,EACtD,OAAO,GAAE;IAGR,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC;IAC3D,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,SAAS,CAAC;CAClE,GACJ,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAc3B;AAMD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAI5D;AAED;;;;;GAKG;AACH,eAAO,MAAM,SAAS,6BAAoB,CAAC"}

package/dist/endpoints/index.d.ts

@@ -0,0 +1,4 @@
+import * as Verify from './verify';
+export { Verify };
+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,MAAM,MAAM,UAAU,CAAC;AAEnC,OAAO,EAAE,MAAM,EAAE,CAAC;AAClB,cAAc,SAAS,CAAC"}

package/dist/endpoints/types.d.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+/** The four results Kickbox assigns to an address. */
+export declare const KICKBOX_RESULTS: readonly ["deliverable", "undeliverable", "risky", "unknown"];
+/**
+ * The reasons Kickbox publishes. It may add another, so the output keeps the
+ * field a plain string rather than failing a read on an unknown one.
+ */
+export declare const KICKBOX_REASONS: readonly ["invalid_email", "invalid_domain", "rejected_email", "accepted_email", "low_quality", "low_deliverability", "no_connect", "timeout", "invalid_smtp", "unavailable_smtp", "unexpected_error"];
+declare const VerifyInputSchema: z.ZodObject<{
+    email: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type VerifyInput = z.input<typeof VerifyInputSchema>;
+declare const VerifyResponseSchema: z.ZodObject<{
+    result: z.ZodUnion<readonly [z.ZodEnum<{
+        unknown: "unknown";
+        deliverable: "deliverable";
+        undeliverable: "undeliverable";
+        risky: "risky";
+    }>, z.ZodString]>;
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    role: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    free: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    disposable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    accept_all: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    did_you_mean: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sendex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    user: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    domain: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    success: z.ZodLiteral<true>;
+    message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export type VerifyResponse = z.infer<typeof VerifyResponseSchema>;
+declare const DisposableInputSchema: z.ZodObject<{
+    address: z.ZodString;
+}, z.core.$strip>;
+export type DisposableInput = z.input<typeof DisposableInputSchema>;
+declare const DisposableResponseSchema: z.ZodObject<{
+    disposable: z.ZodBoolean;
+}, z.core.$loose>;
+export type DisposableResponse = z.infer<typeof DisposableResponseSchema>;
+export type KickboxEndpointInputs = {
+    verify: VerifyInput;
+    disposable: DisposableInput;
+};
+export type KickboxEndpointOutputs = {
+    verify: VerifyResponse;
+    disposable: DisposableResponse;
+};
+export declare const KickboxEndpointInputSchemas: {
+    readonly verify: z.ZodObject<{
+        email: z.ZodString;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly disposable: z.ZodObject<{
+        address: z.ZodString;
+    }, z.core.$strip>;
+};
+export declare const KickboxEndpointOutputSchemas: {
+    readonly verify: z.ZodObject<{
+        result: z.ZodUnion<readonly [z.ZodEnum<{
+            unknown: "unknown";
+            deliverable: "deliverable";
+            undeliverable: "undeliverable";
+            risky: "risky";
+        }>, z.ZodString]>;
+        reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        role: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        free: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        disposable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        accept_all: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        did_you_mean: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        sendex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        user: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        domain: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        success: z.ZodLiteral<true>;
+        message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>;
+    readonly disposable: z.ZodObject<{
+        disposable: 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;AAOxB,sDAAsD;AACtD,eAAO,MAAM,eAAe,+DAKlB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,eAAe,wMAYlB,CAAC;AAIX,QAAA,MAAM,iBAAiB;;;iBAgBrB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;iBA8CjB,CAAC;AAEV,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAIlE,QAAA,MAAM,qBAAqB;;iBAOzB,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,QAAA,MAAM,wBAAwB;;iBAMrB,CAAC;AAEV,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAI1E,MAAM,MAAM,qBAAqB,GAAG;IACnC,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,eAAe,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACpC,MAAM,EAAE,cAAc,CAAC;IACvB,UAAU,EAAE,kBAAkB,CAAC;CAC/B,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;CAG9B,CAAC;AAEX,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;CAG/B,CAAC"}

package/dist/endpoints/verify.d.ts

@@ -0,0 +1,4 @@
+import type { KickboxEndpoints } from '..';
+export declare const verify: KickboxEndpoints['verify'];
+export declare const disposable: KickboxEndpoints['disposable'];
+//# sourceMappingURL=verify.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../endpoints/verify.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,IAAI,CAAC;AAoB3C,eAAO,MAAM,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAuB5C,CAAC;AAKH,eAAO,MAAM,UAAU,EAAE,gBAAgB,CAAC,YAAY,CAepD,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,58 @@
+import type { CorsairErrorHandler } from 'corsair/core';
+export declare const errorHandlers: {
+    QUOTA_ERROR: {
+        match: (error: Error) => boolean;
+        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: (error: Error) => Promise<{
+            maxRetries: number;
+            retryStrategy: "exponential_backoff";
+        }>;
+    };
+    TIMEOUT_ERROR: {
+        match: (error: Error) => boolean;
+        handler: (error: Error) => Promise<{
+            maxRetries: number;
+            retryStrategy: "linear_2s";
+        }>;
+    };
+    NETWORK_ERROR: {
+        match: (error: Error) => boolean;
+        handler: (error: Error) => Promise<{
+            maxRetries: number;
+            retryStrategy: "exponential_backoff";
+        }>;
+    };
+    DEFAULT: {
+        match: () => true;
+        handler: () => Promise<{
+            maxRetries: number;
+        }>;
+    };
+};
+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;AAkBxD,eAAO,MAAM,aAAa;;uBAMT,KAAK;;;;;;uBAML,KAAK;yBACG,KAAK;;;;;;;uBAab,KAAK;;;;;;uBAML,KAAK;;;;;;uBAWL,KAAK;yBACG,KAAK;;;;;;uBAUb,KAAK;yBACG,KAAK;;;;;;uBAMb,KAAK;yBAEG,KAAK;;;;;;;;;;;CASC,CAAC;AAMhC,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,73 @@
+import type { BindEndpoints, CorsairEndpoint, CorsairErrorHandler, CorsairPlugin, CorsairPluginContext, KeyBuilderContext, PickAuth, PluginPermissionsConfig } from 'corsair/core';
+import type { KickboxEndpointInputs, KickboxEndpointOutputs } from './endpoints/types';
+import { KickboxSchema } from './schema';
+export type KickboxPluginOptions = {
+    authType?: PickAuth<'api_key'>;
+    key?: string;
+    /**
+     * `eu` sends verification to `api.eu.kickbox.com`, which is where an EU-only
+     * account is served. Defaults to the standard host.
+     */
+    region?: 'us' | 'eu';
+    hooks?: InternalKickboxPlugin['hooks'];
+    errorHandlers?: CorsairErrorHandler;
+    permissions?: PluginPermissionsConfig<typeof kickboxEndpointsNested>;
+};
+export type KickboxContext = CorsairPluginContext<typeof KickboxSchema, KickboxPluginOptions>;
+export type KickboxKeyBuilderContext = KeyBuilderContext<KickboxPluginOptions>;
+export type KickboxBoundEndpoints = BindEndpoints<typeof kickboxEndpointsNested>;
+type KickboxEndpoint<K extends keyof KickboxEndpointOutputs> = CorsairEndpoint<KickboxContext, KickboxEndpointInputs[K], KickboxEndpointOutputs[K]>;
+export type KickboxEndpoints = {
+    verify: KickboxEndpoint<'verify'>;
+    disposable: KickboxEndpoint<'disposable'>;
+};
+declare const kickboxEndpointsNested: {
+    readonly verify: {
+        readonly verify: KickboxEndpoint<"verify">;
+        readonly disposable: KickboxEndpoint<"disposable">;
+    };
+};
+export declare const kickboxEndpointSchemas: {
+    readonly 'verify.verify': {
+        readonly input: import("zod").ZodObject<{
+            email: import("zod").ZodString;
+            timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            result: import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                unknown: "unknown";
+                deliverable: "deliverable";
+                undeliverable: "undeliverable";
+                risky: "risky";
+            }>, import("zod").ZodString]>;
+            reason: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            role: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+            free: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+            disposable: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+            accept_all: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+            did_you_mean: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            sendex: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+            email: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            user: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            domain: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            success: import("zod").ZodLiteral<true>;
+            message: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        }, import("zod/v4/core").$loose>;
+    };
+    readonly 'verify.disposable': {
+        readonly input: import("zod").ZodObject<{
+            address: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            disposable: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$loose>;
+    };
+};
+declare const defaultAuthType: "api_key";
+export type BaseKickboxPlugin<T extends KickboxPluginOptions> = CorsairPlugin<'kickbox', typeof KickboxSchema, typeof kickboxEndpointsNested, {}, T, typeof defaultAuthType>;
+export type InternalKickboxPlugin = BaseKickboxPlugin<KickboxPluginOptions>;
+export type ExternalKickboxPlugin<T extends KickboxPluginOptions> = BaseKickboxPlugin<T>;
+export declare function kickbox<const T extends KickboxPluginOptions>(incomingOptions?: KickboxPluginOptions & T): ExternalKickboxPlugin<T>;
+export { isKickboxAuthError, isKickboxQuotaError, isPaidKickboxRequest, KickboxAPIError, kickboxErrorCode, kickboxErrorStatus, } from './client';
+export type { DisposableInput, DisposableResponse, KickboxEndpointInputs, KickboxEndpointOutputs, VerifyInput, VerifyResponse, } 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;AAM3B,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;;;OAGG;IACH,MAAM,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACrB,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,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC;IAClC,UAAU,EAAE,eAAe,CAAC,YAAY,CAAC,CAAC;CAC1C,CAAC;AAEF,QAAA,MAAM,sBAAsB;;;;;CAKlB,CAAC;AAEX,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWlC,CAAC;AAEF,QAAA,MAAM,eAAe,EAAG,SAAkB,CAAC;AAiB3C,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,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,GAClB,MAAM,UAAU,CAAC;AAElB,YAAY,EACX,eAAe,EACf,kBAAkB,EAClB,qBAAqB,EACrB,sBAAsB,EACtB,WAAW,EACX,cAAc,GACd,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+var L=Object.defineProperty;var q=(e,t)=>{for(var n in t)L(e,n,{get:t[n],enumerable:!0})};import{AuthMissingError as te}from"corsair/core";var b={};q(b,{disposable:()=>Y,verify:()=>J});import{asRecord as N}from"corsair/core";import{ApiError as f,request as H}from"corsair/http";var _="https://api.kickbox.com",C="https://api.eu.kickbox.com",x="https://open.kickbox.com",h="/v1/disposable/",V=35e3;function y(e){let t=N(e),n=a=>{let p=t?.[a];return typeof p=="string"&&p.length>0?p:void 0},i=t?.success,r=n("message"),s=n("code")??(r&&/insufficient balance/i.test(r)?"INSUFFICIENT_BALANCE":void 0);return{success:typeof i=="boolean"?i:void 0,code:s,message:r}}var z={enabled:!0,maxRetries:0,initialRetryDelay:1e3,backoffMultiplier:2,headerNames:{retryAfter:"retry-after"}},c=class extends Error{status;code;retryAfter;method;transport;timedOut;paid;constructor(t,n={}){super(t,n.cause?{cause:n.cause}:void 0),this.name="KickboxAPIError",this.status=n.status,this.code=n.code,this.retryAfter=n.retryAfter,this.method=n.method,this.transport=n.transport??!1,this.timedOut=n.timedOut??!1,this.paid=n.paid??!1}get isRateLimit(){return this.status===429}get isAuthError(){return this.isQuotaError?!1:this.status===401||this.status===403||this.code==="FORBIDDEN"}get isQuotaError(){return this.code==="INSUFFICIENT_BALANCE"}get isValidationError(){return this.status===400||this.status===422}};function k(e){if(e instanceof f||e instanceof c)return e.status}function g(e){if(e instanceof f)return y(e.body).code;if(e instanceof c)return e.code}function E(e){return g(e)==="INSUFFICIENT_BALANCE"}function K(e){if(E(e))return!1;let t=k(e);return t===401||t===403||g(e)==="FORBIDDEN"}function R(e){return e instanceof c?e.paid:e instanceof f?!e.request.url.startsWith(h):!1}function A(e){return e.replace(/([?&]email=)[^&#]*/g,"$1[REDACTED]").replace(/(\/v1\/disposable\/)[^?#]*/,"$1[REDACTED]")}function U(e){let t=y(e.body),n=Object.fromEntries(Object.entries({success:t.success,code:t.code}).filter(([,s])=>s!==void 0)),i=[e.status,t.code].filter(s=>s!==void 0).join(" "),r=e.request.query?Object.fromEntries(Object.entries(e.request.query).map(([s,a])=>[s,s==="email"?"[REDACTED]":a])):void 0;return new f({...e.request,url:A(e.request.url),...r?{query:r}:{}},{url:A(e.url),ok:!1,status:e.status,statusText:e.statusText,body:n},`Kickbox ${i}: request failed`,{retryAfter:e.retryAfter,rateLimitReset:e.rateLimitReset,rateLimitRemaining:e.rateLimitRemaining,rateLimitLimit:e.rateLimitLimit})}function F(e,t,n){let i=y(t),r=i.message??n,s=[e,i.code].filter(a=>a!==void 0).join(" ");return s?`Kickbox ${s}: ${r}`:r}function T(e){return encodeURIComponent(e)}async function S(e,{method:t,base:n,path:i,query:r}){let s={BASE:n,VERSION:"2.0.0",WITH_CREDENTIALS:!1,CREDENTIALS:"omit",TIMEOUT:V,HEADERS:{Accept:"application/json"}},a=n!==x,p={method:t,url:i,query:r};try{let u=await H(s,p,{rateLimitConfig:z}),m=y(u);if(m.success===!1)throw new c(F(void 0,u,"Kickbox refused the request"),{status:200,code:m.code,method:t,paid:a});return u}catch(u){throw u instanceof c?u:u instanceof f?U(u):u instanceof Error||u instanceof DOMException?new c(u.message,{cause:u,method:t,transport:!0,timedOut:u.name==="TimeoutError",paid:a}):new c("Unknown Kickbox error",{method:t,transport:!0,paid:a})}}function v(e){return Object.fromEntries(Object.entries(e).filter(t=>t[1]!==void 0))}import{logEventFromContext as j}from"corsair/core";async function O(e,t,n,i,r={}){let s=t.input.parse(n??{}),a=await S(e.key,i(s)),p=t.output.parse(r.shape?r.shape(a,s):a);return await j(e,`kickbox.${t.event}`,r.log?.(s,p)??{},"completed"),p}var M=/^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/;function P(e){let t=e.lastIndexOf("@"),n=(t===-1?e:e.slice(t+1)).toLowerCase();return M.test(n)?n:void 0}import{z as o}from"zod";var Q=["deliverable","undeliverable","risky","unknown"];var X=o.object({email:o.string().min(3).describe("The address to verify. It is URL-encoded for you. Send a syntactically bad one to have Kickbox report `invalid_email` rather than rejecting it here."),timeout:o.number().int().min(1).max(3e4).optional().describe("How long Kickbox may spend on the SMTP check, in milliseconds. Defaults to 6000, and 30000 is the ceiling.")}),$=o.object({result:o.union([o.enum(Q),o.string()]).describe("`deliverable`, `undeliverable`, `risky` or `unknown`."),reason:o.string().nullish().describe("Why the result came out as it did, such as `accepted_email` or `rejected_email`."),role:o.boolean().nullish().describe("True for a role address such as `support@example.com`."),free:o.boolean().nullish().describe("True for a free provider such as gmail.com."),disposable:o.boolean().nullish().describe("True when the domain is a known disposable one."),accept_all:o.boolean().nullish().describe("True when the domain accepts every address it is offered."),did_you_mean:o.string().nullish().describe("A suggested spelling when Kickbox spotted a likely typo."),sendex:o.number().nullish().describe("A quality score from 0 (no quality) to 1 (perfect)."),email:o.string().nullish().describe("The address in normalized lower case."),user:o.string().nullish(),domain:o.string().nullish(),success:o.literal(!0),message:o.string().nullish()}).loose(),W=o.object({address:o.string().min(3).describe("An email address or a bare domain, such as `mailinator.com`. It is URL-encoded for you.")}),G=o.object({disposable:o.boolean().describe("True when the domain is a known disposable one.")}).loose(),d={verify:X,disposable:W},l={verify:$,disposable:G};function Z(e){return e==="eu"?C:_}var J=(e,t)=>O(e,{event:"verify.verify",input:d.verify,output:l.verify},t,({email:n,timeout:i})=>({method:"GET",base:Z(e.options.region),path:"/v2/verify",query:v({email:n,apikey:e.key,timeout:i})}),{log:(n,i)=>({domain:i.domain??void 0,result:i.result,reason:i.reason??void 0})}),Y=(e,t)=>O(e,{event:"verify.disposable",input:d.disposable,output:l.disposable},t,({address:n})=>({method:"GET",base:x,path:`${h}${T(n)}`}),{log:({address:n})=>({domain:P(n)})});import{ApiError as ee}from"corsair/http";function I(e){return k(e)}var w={QUOTA_ERROR:{match:e=>E(e),handler:async()=>({maxRetries:0})},RATE_LIMIT_ERROR:{match:e=>I(e)===429,handler:async e=>({maxRetries:2,headersRetryAfterMs:e instanceof ee||e instanceof c?e.retryAfter:void 0,retryStrategy:"exponential_backoff"})},AUTH_ERROR:{match:e=>K(e),handler:async()=>({maxRetries:0})},VALIDATION_ERROR:{match:e=>{let t=I(e);return e.name==="ZodError"||t===400||t===422},handler:async()=>({maxRetries:0})},SERVER_ERROR:{match:e=>(I(e)??0)>=500,handler:async e=>({maxRetries:R(e)?0:2,retryStrategy:"exponential_backoff"})},TIMEOUT_ERROR:{match:e=>e instanceof c&&e.timedOut,handler:async e=>({maxRetries:e instanceof c&&e.paid?0:1,retryStrategy:"linear_2s"})},NETWORK_ERROR:{match:e=>e instanceof c&&e.transport,handler:async e=>({maxRetries:e instanceof c&&e.paid?0:2,retryStrategy:"exponential_backoff"})},DEFAULT:{match:()=>!0,handler:async()=>({maxRetries:0})}};function B(e,t){if(!t)return e;let{DEFAULT:n,...i}=e,{DEFAULT:r,...s}=t,a={...s};for(let[u,m]of Object.entries(i))u in a||(a[u]=m);let p=r??n;return p&&(a.DEFAULT=p),a}var D={version:"1.0.0",entities:{}};var ne={verify:{verify:b.verify,disposable:b.disposable}},oe={"verify.verify":{input:d.verify,output:l.verify},"verify.disposable":{input:d.disposable,output:l.disposable}},ie="api_key",re={"verify.verify":{riskLevel:"read",description:"Verify one address and get its verdict (deliverable, undeliverable, risky, unknown), the reason, role and free flags, a typo suggestion and a Sendex quality score. Spends one verification credit"},"verify.disposable":{riskLevel:"read",description:"Check whether an address or domain is a known disposable one. Free, and answered by Kickbox\u2019s open service"}};function Te(e={}){let t={...e,authType:e.authType??ie};return{id:"kickbox",schema:D,options:t,hooks:t.hooks,endpoints:ne,webhooks:{},endpointMeta:re,endpointSchemas:oe,pluginWebhookMatcher:()=>!1,errorHandlers:B(w,t.errorHandlers),keyBuilder:async(n,i)=>{if(i==="endpoint"&&t.key)return t.key;if(i==="endpoint"&&n.authType==="api_key"){let r=await n.keys.get_api_key();if(r)return r}throw new te("kickbox",n.authType??"api_key")}}}export{c as KickboxAPIError,K as isKickboxAuthError,E as isKickboxQuotaError,R as isPaidKickboxRequest,Te as kickbox,oe as kickboxEndpointSchemas,g as kickboxErrorCode,k as kickboxErrorStatus};

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/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 KickboxSchema: {
+    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":"AAAA,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,78 @@
+export declare const deliverable: {
+    result: string;
+    reason: string;
+    role: boolean;
+    free: boolean;
+    disposable: boolean;
+    accept_all: boolean;
+    did_you_mean: null;
+    sendex: number;
+    email: string;
+    user: string;
+    domain: string;
+    success: boolean;
+    message: null;
+};
+export declare const undeliverable: {
+    result: string;
+    reason: string;
+    role: boolean;
+    free: boolean;
+    disposable: boolean;
+    accept_all: boolean;
+    did_you_mean: string;
+    sendex: number;
+    email: string;
+    user: string;
+    domain: string;
+    success: boolean;
+    message: null;
+};
+export declare const risky: {
+    result: string;
+    reason: string;
+    role: boolean;
+    free: boolean;
+    disposable: boolean;
+    accept_all: boolean;
+    did_you_mean: null;
+    sendex: number;
+    email: string;
+    user: string;
+    domain: string;
+    success: boolean;
+    message: null;
+};
+export declare const disposableHost: {
+    disposable: boolean;
+};
+export declare const notDisposableHost: {
+    disposable: boolean;
+};
+/** The 403 body Kickbox sends for a key it does not recognise. */
+export declare const invalidKey: {
+    success: boolean;
+    code: string;
+    message: string;
+};
+/** The 200 that still says the key is refused, which is the trap. */
+export declare const refusedKeyOn200: {
+    success: boolean;
+    code: string;
+    message: string;
+};
+/**
+ * A spent balance, as the live API sends it: a 403 with no `code`, only the
+ * message (sandbox key, `insufficient-balance@example.com`, 11-14).
+ */
+export declare const insufficientBalance: {
+    success: boolean;
+    message: string;
+};
+/** An address Kickbox will not accept. */
+export declare const badRequest: {
+    success: boolean;
+    code: string;
+    message: 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":"AAIA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;CAcvB,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;CAczB,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;CAcjB,CAAC;AAEF,eAAO,MAAM,cAAc;;CAAuB,CAAC;AACnD,eAAO,MAAM,iBAAiB;;CAAwB,CAAC;AAEvD,kEAAkE;AAClE,eAAO,MAAM,UAAU;;;;CAItB,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,eAAe;;;;CAI3B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;CAG/B,CAAC;AAEF,0CAA0C;AAC1C,eAAO,MAAM,UAAU;;;;CAItB,CAAC"}

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/kickbox",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Kickbox plugin for Corsair: verify a single email address for deliverability, role, free and disposable flags, typo suggestions and a Sendex quality score, and check whether a domain is a known disposable one.",
+  "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.0",
+    "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.184"
+  },
+  "keywords": [
+    "corsair",
+    "kickbox",
+    "plugin",
+    "email-verification",
+    "deliverability"
+  ],
+  "author": "Corsair (https://corsair.dev)",
+  "license": "Apache-2.0",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/corsairdev/corsair.git",
+    "directory": "packages/kickbox"
+  },
+  "homepage": "https://docs.corsair.dev/plugins/kickbox",
+  "scripts": {
+    "build": "rm -rf dist && tsc --build --force && tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "jest",
+    "test:live": "jest --testPathIgnorePatterns=/node_modules/ --testPathPattern=api\\.test\\.ts"
+  }
 }