@corsair-dev/abuseipdb 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/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,48 @@
+/**
+ * Error thrown for any non-2xx AbuseIPDB response. Preserves the HTTP status,
+ * response body, and rate-limit headers from the underlying `ApiError` so
+ * `error-handlers.ts` can inspect them without re-requesting.
+ */
+export declare class AbuseIPDBAPIError extends Error {
+    readonly code?: number | undefined;
+    readonly status?: number;
+    readonly statusText?: string;
+    /**
+     * The raw response body. Deliberately `unknown` — AbuseIPDB returns
+     * JSON:API-shaped errors (`{ errors: [{ detail, status, source }] }`)
+     * that don't map to a single known schema, so callers narrow it
+     * themselves (see error-handlers.ts).
+     */
+    readonly body?: unknown;
+    readonly retryAfter?: number;
+    readonly rateLimitReset?: number;
+    readonly rateLimitRemaining?: number;
+    readonly rateLimitLimit?: number;
+    constructor(message: string, code?: number | undefined, options?: {
+        cause?: Error;
+    });
+}
+/**
+ * Safely reads the stored API key from the account key manager.
+ *
+ * `ctx.keys.get_api_key()` throws (rather than returning null) when the
+ * account has no DEK at all — a fully valid state for accounts that only
+ * ever configure the key via plugin options and never touch the key
+ * manager, and must resolve to "no stored key" rather than abort the
+ * request.
+ *
+ * Anything else thrown (decryption failure, database error, ...) is a real
+ * operational problem, not an absent key, and must propagate.
+ */
+export declare function tryGetStoredKey(getter: () => Promise<string | null | undefined>): Promise<string | undefined>;
+/**
+ * AbuseIPDB API v2 base URL. All endpoints live under `/api/v2`.
+ */
+export declare const ABUSEIPDB_API_BASE = "https://api.abuseipdb.com/api/v2";
+export declare function makeAbuseIPDBRequest<T>(endpoint: string, apiKey: string, options?: {
+    method?: 'GET' | 'POST' | 'DELETE';
+    query?: Record<string, string | number | boolean | undefined>;
+    formBody?: Record<string, string | number | undefined>;
+    retries?: boolean;
+}): Promise<T>;
+//# 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":"AAOA;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;aAiB1B,IAAI,CAAC,EAAE,MAAM;IAhB9B,SAAgB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChC,SAAgB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpC;;;;;OAKG;IACH,SAAgB,IAAI,CAAC,EAAE,OAAO,CAAC;IAC/B,SAAgB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpC,SAAgB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxC,SAAgB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5C,SAAgB,cAAc,CAAC,EAAE,MAAM,CAAC;gBAGvC,OAAO,EAAE,MAAM,EACC,IAAI,CAAC,EAAE,MAAM,YAAA,EAC7B,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE;CAe5B;AASD;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CACpC,MAAM,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAC9C,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAU7B;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,qCAAqC,CAAC;AAyCrE,wBAAsB,oBAAoB,CAAC,CAAC,EAC3C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IACR,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,CAAC;IAC9D,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC,CAAC;IACvD,OAAO,CAAC,EAAE,OAAO,CAAC;CACb,GACJ,OAAO,CAAC,CAAC,CAAC,CAwEZ"}

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/blacklist.d.ts

@@ -0,0 +1,10 @@
+import type { AbuseIPDBEndpoints } from '../index';
+/**
+ * Download the blacklist of most-reported IPs, optionally filtered by
+ * confidence minimum, country, and IP version.
+ *
+ * API: GET /api/v2/blacklist
+ * Docs: https://docs.abuseipdb.com/#blacklist-endpoint
+ */
+export declare const get: AbuseIPDBEndpoints['getBlacklist'];
+//# sourceMappingURL=blacklist.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blacklist.d.ts","sourceRoot":"","sources":["../../endpoints/blacklist.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAGnD;;;;;;GAMG;AACH,eAAO,MAAM,GAAG,EAAE,kBAAkB,CAAC,cAAc,CA4ClD,CAAC"}

package/dist/endpoints/check-block.d.ts

@@ -0,0 +1,10 @@
+import type { AbuseIPDBEndpoints } from '../index';
+/**
+ * Check a CIDR network block and list the addresses within it that have
+ * been reported to AbuseIPDB.
+ *
+ * API: GET /api/v2/check-block
+ * Docs: https://docs.abuseipdb.com/#check-block-endpoint
+ */
+export declare const check: AbuseIPDBEndpoints['checkBlock'];
+//# sourceMappingURL=check-block.d.ts.map

package/dist/endpoints/check-block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-block.d.ts","sourceRoot":"","sources":["../../endpoints/check-block.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAInD;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,EAAE,kBAAkB,CAAC,YAAY,CAwBlD,CAAC"}

package/dist/endpoints/check.d.ts

@@ -0,0 +1,10 @@
+import type { AbuseIPDBEndpoints } from '../index';
+/**
+ * Look up an IP address and get its abuse confidence score, country, ISP,
+ * usage type, and optionally recent reports (verbose).
+ *
+ * API: GET /api/v2/check
+ * Docs: https://docs.abuseipdb.com/#check-endpoint
+ */
+export declare const check: AbuseIPDBEndpoints['checkIp'];
+//# sourceMappingURL=check.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../endpoints/check.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAInD;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,EAAE,kBAAkB,CAAC,SAAS,CAmD/C,CAAC"}

package/dist/endpoints/clear-address.d.ts

@@ -0,0 +1,10 @@
+import type { AbuseIPDBEndpoints } from '../index';
+/**
+ * Remove all reports for an IP address from your account, and return the
+ * number of reports that were deleted.
+ *
+ * API: DELETE /api/v2/clear-address
+ * Docs: https://docs.abuseipdb.com/#clear-address-endpoint
+ */
+export declare const clear: AbuseIPDBEndpoints['clearAddress'];
+//# sourceMappingURL=clear-address.d.ts.map

package/dist/endpoints/clear-address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clear-address.d.ts","sourceRoot":"","sources":["../../endpoints/clear-address.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAInD;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,EAAE,kBAAkB,CAAC,cAAc,CAuCpD,CAAC"}

package/dist/endpoints/index.d.ts

@@ -0,0 +1,121 @@
+export declare const CheckIp: {
+    check: (ctx: import("..").AbuseIPDBContext, args: {
+        ipAddress: string;
+        maxAgeInDays?: number | undefined;
+        verbose?: boolean | undefined;
+    }) => Promise<{
+        [x: string]: unknown;
+        ipAddress: string;
+        isPublic: boolean;
+        ipVersion: number;
+        isWhitelisted: boolean | null;
+        abuseConfidenceScore: number;
+        hostnames: string[];
+        isTor: boolean;
+        totalReports: number;
+        numDistinctUsers: number;
+        countryCode?: string | null | undefined;
+        countryName?: string | null | undefined;
+        usageType?: string | null | undefined;
+        isp?: string | null | undefined;
+        domain?: string | null | undefined;
+        lastReportedAt?: string | null | undefined;
+        reports?: {
+            [x: string]: unknown;
+            reportedAt: string;
+            categories: number[];
+            reporterId: number;
+            comment?: string | null | undefined;
+            reporterCountryCode?: string | null | undefined;
+            reporterCountryName?: string | null | undefined;
+        }[] | undefined;
+    }>;
+};
+export declare const Reports: {
+    list: (ctx: import("..").AbuseIPDBContext, args: {
+        ipAddress: string;
+        maxAgeInDays?: number | undefined;
+        page?: number | undefined;
+        perPage?: number | undefined;
+    }) => Promise<{
+        [x: string]: unknown;
+        total: number;
+        page: number;
+        count: number;
+        perPage: number;
+        lastPage: number;
+        results: {
+            [x: string]: unknown;
+            reportedAt: string;
+            categories: number[];
+            reporterId: number;
+            comment?: string | null | undefined;
+            reporterCountryCode?: string | null | undefined;
+            reporterCountryName?: string | null | undefined;
+        }[];
+        nextPageUrl?: string | null | undefined;
+        previousPageUrl?: string | null | undefined;
+    }>;
+};
+export declare const Blacklist: {
+    get: (ctx: import("..").AbuseIPDBContext, args: {
+        confidenceMinimum?: number | undefined;
+        limit?: number | undefined;
+        onlyCountries?: string[] | undefined;
+        exceptCountries?: string[] | undefined;
+        ipVersion?: 4 | 6 | undefined;
+    }) => Promise<{
+        generatedAt: string;
+        entries: {
+            [x: string]: unknown;
+            ipAddress: string;
+            abuseConfidenceScore: number;
+            lastReportedAt?: string | null | undefined;
+            countryCode?: string | null | undefined;
+        }[];
+    }>;
+};
+export declare const ReportIp: {
+    report: (ctx: import("..").AbuseIPDBContext, args: {
+        ip: string;
+        categories: number[];
+        comment?: string | undefined;
+        timestamp?: string | undefined;
+    }) => Promise<{
+        [x: string]: unknown;
+        ipAddress: string;
+        abuseConfidenceScore: number;
+    }>;
+};
+export declare const CheckBlock: {
+    check: (ctx: import("..").AbuseIPDBContext, args: {
+        network: string;
+        maxAgeInDays?: number | undefined;
+    }) => Promise<{
+        [x: string]: unknown;
+        networkAddress: string;
+        netmask: string;
+        minAddress: string;
+        maxAddress: string;
+        numPossibleHosts: number;
+        reportedAddress: {
+            [x: string]: unknown;
+            ipAddress: string;
+            numReports: number;
+            abuseConfidenceScore: number;
+            mostRecentReport?: string | null | undefined;
+            countryCode?: string | null | undefined;
+        }[];
+        addressSpaceDesc?: string | null | undefined;
+    }>;
+};
+export declare const ClearAddress: {
+    clear: (ctx: import("..").AbuseIPDBContext, args: {
+        ipAddress: string;
+    }) => Promise<{
+        [x: string]: unknown;
+        numReportsDeleted: number;
+    }>;
+};
+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":"AAOA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEnB,CAAC;AAEF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;CAEnB,CAAC;AAEF,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;CAErB,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;;;;;;;;CAEpB,CAAC;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;CAEtB,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;;;CAExB,CAAC;AAEF,cAAc,SAAS,CAAC"}

package/dist/endpoints/output-validation.test.d.ts

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

package/dist/endpoints/output-validation.test.d.ts.map

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

package/dist/endpoints/report.d.ts

@@ -0,0 +1,12 @@
+import type { AbuseIPDBEndpoints } from '../index';
+/**
+ * Submit an abuse report for an IP address.
+ *
+ * The `categories` field accepts numeric category IDs (integers 1–30) —
+ * see https://www.abuseipdb.com/categories for the mapping.
+ *
+ * API: POST /api/v2/report
+ * Docs: https://docs.abuseipdb.com/#report-endpoint
+ */
+export declare const report: AbuseIPDBEndpoints['reportIp'];
+//# sourceMappingURL=report.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../endpoints/report.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAInD;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,EAAE,kBAAkB,CAAC,UAAU,CA4CjD,CAAC"}

package/dist/endpoints/reports.d.ts

@@ -0,0 +1,9 @@
+import type { AbuseIPDBEndpoints } from '../index';
+/**
+ * Get a paginated list of abuse reports filed against a single IP address.
+ *
+ * API: GET /api/v2/reports
+ * Docs: https://docs.abuseipdb.com/#reports-endpoint
+ */
+export declare const list: AbuseIPDBEndpoints['getReports'];
+//# sourceMappingURL=reports.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reports.d.ts","sourceRoot":"","sources":["../../endpoints/reports.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAInD;;;;;GAKG;AACH,eAAO,MAAM,IAAI,EAAE,kBAAkB,CAAC,YAAY,CA0BjD,CAAC"}

package/dist/endpoints/types.d.ts

@@ -0,0 +1,242 @@
+import { z } from 'zod';
+export declare const CheckIpInputSchema: z.ZodObject<{
+    ipAddress: z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6]>;
+    maxAgeInDays: z.ZodOptional<z.ZodNumber>;
+    verbose: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type CheckIpInput = z.infer<typeof CheckIpInputSchema>;
+export declare const CheckIpResponseSchema: z.ZodObject<{
+    ipAddress: z.ZodString;
+    isPublic: z.ZodBoolean;
+    ipVersion: z.ZodNumber;
+    isWhitelisted: z.ZodNullable<z.ZodBoolean>;
+    abuseConfidenceScore: z.ZodNumber;
+    countryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    countryName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    usageType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isp: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    domain: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    hostnames: z.ZodArray<z.ZodString>;
+    isTor: z.ZodBoolean;
+    totalReports: z.ZodNumber;
+    numDistinctUsers: z.ZodNumber;
+    lastReportedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    reports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        reportedAt: z.ZodString;
+        comment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        categories: z.ZodArray<z.ZodNumber>;
+        reporterId: z.ZodNumber;
+        reporterCountryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reporterCountryName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type CheckIpResponse = z.infer<typeof CheckIpResponseSchema>;
+export declare const GetReportsInputSchema: z.ZodObject<{
+    ipAddress: z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6]>;
+    maxAgeInDays: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNumber>;
+    perPage: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type GetReportsInput = z.infer<typeof GetReportsInputSchema>;
+export declare const GetReportsResponseSchema: z.ZodObject<{
+    total: z.ZodNumber;
+    page: z.ZodNumber;
+    count: z.ZodNumber;
+    perPage: z.ZodNumber;
+    lastPage: z.ZodNumber;
+    nextPageUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    previousPageUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    results: z.ZodArray<z.ZodObject<{
+        reportedAt: z.ZodString;
+        comment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        categories: z.ZodArray<z.ZodNumber>;
+        reporterId: z.ZodNumber;
+        reporterCountryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reporterCountryName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type GetReportsResponse = z.infer<typeof GetReportsResponseSchema>;
+export declare const GetBlacklistInputSchema: z.ZodObject<{
+    confidenceMinimum: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    onlyCountries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exceptCountries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ipVersion: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<4>, z.ZodLiteral<6>]>>;
+}, z.core.$strip>;
+export type GetBlacklistInput = z.infer<typeof GetBlacklistInputSchema>;
+export declare const GetBlacklistResponseSchema: z.ZodObject<{
+    generatedAt: z.ZodString;
+    entries: z.ZodArray<z.ZodObject<{
+        ipAddress: z.ZodString;
+        abuseConfidenceScore: z.ZodNumber;
+        lastReportedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        countryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export type GetBlacklistResponse = z.infer<typeof GetBlacklistResponseSchema>;
+export declare const ReportIpInputSchema: z.ZodObject<{
+    ip: z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6]>;
+    categories: z.ZodArray<z.ZodNumber>;
+    comment: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type ReportIpInput = z.infer<typeof ReportIpInputSchema>;
+export declare const ReportIpResponseSchema: z.ZodObject<{
+    ipAddress: z.ZodString;
+    abuseConfidenceScore: z.ZodNumber;
+}, z.core.$loose>;
+export type ReportIpResponse = z.infer<typeof ReportIpResponseSchema>;
+export declare const CheckBlockInputSchema: z.ZodObject<{
+    network: z.ZodUnion<readonly [z.ZodCIDRv4, z.ZodCIDRv6]>;
+    maxAgeInDays: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type CheckBlockInput = z.infer<typeof CheckBlockInputSchema>;
+export declare const CheckBlockResponseSchema: z.ZodObject<{
+    networkAddress: z.ZodString;
+    netmask: z.ZodString;
+    minAddress: z.ZodString;
+    maxAddress: z.ZodString;
+    numPossibleHosts: z.ZodNumber;
+    addressSpaceDesc: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    reportedAddress: z.ZodArray<z.ZodObject<{
+        ipAddress: z.ZodString;
+        numReports: z.ZodNumber;
+        mostRecentReport: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        abuseConfidenceScore: z.ZodNumber;
+        countryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type CheckBlockResponse = z.infer<typeof CheckBlockResponseSchema>;
+export declare const ClearAddressInputSchema: z.ZodObject<{
+    ipAddress: z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6]>;
+}, z.core.$strip>;
+export type ClearAddressInput = z.infer<typeof ClearAddressInputSchema>;
+export declare const ClearAddressResponseSchema: z.ZodObject<{
+    numReportsDeleted: z.ZodNumber;
+}, z.core.$loose>;
+export type ClearAddressResponse = z.infer<typeof ClearAddressResponseSchema>;
+export type AbuseIPDBEndpointInputs = {
+    checkIp: CheckIpInput;
+    getReports: GetReportsInput;
+    getBlacklist: GetBlacklistInput;
+    reportIp: ReportIpInput;
+    checkBlock: CheckBlockInput;
+    clearAddress: ClearAddressInput;
+};
+export type AbuseIPDBEndpointOutputs = {
+    checkIp: CheckIpResponse;
+    getReports: GetReportsResponse;
+    getBlacklist: GetBlacklistResponse;
+    reportIp: ReportIpResponse;
+    checkBlock: CheckBlockResponse;
+    clearAddress: ClearAddressResponse;
+};
+export declare const AbuseIPDBEndpointInputSchemas: {
+    readonly checkIp: z.ZodObject<{
+        ipAddress: z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6]>;
+        maxAgeInDays: z.ZodOptional<z.ZodNumber>;
+        verbose: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly getReports: z.ZodObject<{
+        ipAddress: z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6]>;
+        maxAgeInDays: z.ZodOptional<z.ZodNumber>;
+        page: z.ZodOptional<z.ZodNumber>;
+        perPage: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly getBlacklist: z.ZodObject<{
+        confidenceMinimum: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        onlyCountries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exceptCountries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        ipVersion: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<4>, z.ZodLiteral<6>]>>;
+    }, z.core.$strip>;
+    readonly reportIp: z.ZodObject<{
+        ip: z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6]>;
+        categories: z.ZodArray<z.ZodNumber>;
+        comment: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strip>;
+    readonly checkBlock: z.ZodObject<{
+        network: z.ZodUnion<readonly [z.ZodCIDRv4, z.ZodCIDRv6]>;
+        maxAgeInDays: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly clearAddress: z.ZodObject<{
+        ipAddress: z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6]>;
+    }, z.core.$strip>;
+};
+export declare const AbuseIPDBEndpointOutputSchemas: {
+    readonly checkIp: z.ZodObject<{
+        ipAddress: z.ZodString;
+        isPublic: z.ZodBoolean;
+        ipVersion: z.ZodNumber;
+        isWhitelisted: z.ZodNullable<z.ZodBoolean>;
+        abuseConfidenceScore: z.ZodNumber;
+        countryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        countryName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        usageType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        isp: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        domain: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        hostnames: z.ZodArray<z.ZodString>;
+        isTor: z.ZodBoolean;
+        totalReports: z.ZodNumber;
+        numDistinctUsers: z.ZodNumber;
+        lastReportedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            reportedAt: z.ZodString;
+            comment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            categories: z.ZodArray<z.ZodNumber>;
+            reporterId: z.ZodNumber;
+            reporterCountryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            reporterCountryName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>;
+    readonly getReports: z.ZodObject<{
+        total: z.ZodNumber;
+        page: z.ZodNumber;
+        count: z.ZodNumber;
+        perPage: z.ZodNumber;
+        lastPage: z.ZodNumber;
+        nextPageUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        previousPageUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        results: z.ZodArray<z.ZodObject<{
+            reportedAt: z.ZodString;
+            comment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            categories: z.ZodArray<z.ZodNumber>;
+            reporterId: z.ZodNumber;
+            reporterCountryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            reporterCountryName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+    readonly getBlacklist: z.ZodObject<{
+        generatedAt: z.ZodString;
+        entries: z.ZodArray<z.ZodObject<{
+            ipAddress: z.ZodString;
+            abuseConfidenceScore: z.ZodNumber;
+            lastReportedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            countryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>>;
+    }, z.core.$strip>;
+    readonly reportIp: z.ZodObject<{
+        ipAddress: z.ZodString;
+        abuseConfidenceScore: z.ZodNumber;
+    }, z.core.$loose>;
+    readonly checkBlock: z.ZodObject<{
+        networkAddress: z.ZodString;
+        netmask: z.ZodString;
+        minAddress: z.ZodString;
+        maxAddress: z.ZodString;
+        numPossibleHosts: z.ZodNumber;
+        addressSpaceDesc: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reportedAddress: z.ZodArray<z.ZodObject<{
+            ipAddress: z.ZodString;
+            numReports: z.ZodNumber;
+            mostRecentReport: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            abuseConfidenceScore: z.ZodNumber;
+            countryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+    readonly clearAddress: z.ZodObject<{
+        numReportsDeleted: z.ZodNumber;
+    }, z.core.$loose>;
+};
+//# 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;AAYxB,eAAO,MAAM,kBAAkB;;;;iBAa7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAa9D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;iBAmBzB,CAAC;AAEV,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAQpE,eAAO,MAAM,qBAAqB;;;;;iBA4BhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAIpE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;iBAW5B,CAAC;AAEV,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAS1E,eAAO,MAAM,uBAAuB;;;;;;iBAgClC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAWxE,eAAO,MAAM,0BAA0B;;;;;;;;iBAGrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAQ9E,eAAO,MAAM,mBAAmB;;;;;iBAkB9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,sBAAsB;;;iBAK1B,CAAC;AAEV,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAQtE,eAAO,MAAM,qBAAqB;;;iBAahC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAYpE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;iBAU5B,CAAC;AAEV,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAQ1E,eAAO,MAAM,uBAAuB;;iBAKlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,0BAA0B;;iBAI9B,CAAC;AAEV,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAM9E,MAAM,MAAM,uBAAuB,GAAG;IACrC,OAAO,EAAE,YAAY,CAAC;IACtB,UAAU,EAAE,eAAe,CAAC;IAC5B,YAAY,EAAE,iBAAiB,CAAC;IAChC,QAAQ,EAAE,aAAa,CAAC;IACxB,UAAU,EAAE,eAAe,CAAC;IAC5B,YAAY,EAAE,iBAAiB,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACtC,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,kBAAkB,CAAC;IAC/B,YAAY,EAAE,oBAAoB,CAAC;IACnC,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,UAAU,EAAE,kBAAkB,CAAC;IAC/B,YAAY,EAAE,oBAAoB,CAAC;CACnC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOhC,CAAC;AAEX,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOjC,CAAC"}

package/dist/error-handlers.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Error handlers for the AbuseIPDB plugin.
+ *
+ * AbuseIPDB returns reliable HTTP status codes:
+ * - 401: invalid, missing, or unauthorized API key
+ * - 402: plan tier limit exceeded (e.g. check-block network too large)
+ * - 422: malformed/out-of-range parameter (e.g. maxAgeInDays > 365)
+ * - 429: daily per-endpoint rate limit exceeded (Retry-After header)
+ * - 5xx: internal server error
+ */
+export declare const errorHandlers: {
+    RATE_LIMIT_ERROR: {
+        match: (error: Error) => boolean;
+        handler: (error: Error) => Promise<{
+            maxRetries: number;
+            headersRetryAfterMs: number | undefined;
+        }>;
+    };
+    AUTH_ERROR: {
+        match: (error: Error) => boolean;
+        handler: () => Promise<{
+            maxRetries: number;
+        }>;
+    };
+    PAYMENT_REQUIRED_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;
+        }>;
+    };
+    DEFAULT: {
+        match: () => true;
+        handler: (error: Error) => Promise<{
+            maxRetries: number;
+        }>;
+    };
+};
+//# 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":"AAmBA;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa;;uBAET,KAAK;yBAKG,KAAK;;;;;;uBAQb,KAAK;;;;;;uBAkBL,KAAK;;;;;;uBAeL,KAAK;;;;;;uBAcL,KAAK;;;;;;;yBAYG,KAAK;;;;CAKC,CAAC"}

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,186 @@
+import type { BindEndpoints, CorsairEndpoint, CorsairErrorHandler, CorsairPlugin, CorsairPluginContext, KeyBuilderContext, PickAuth, PluginPermissionsConfig } from 'corsair/core';
+import type { AbuseIPDBEndpointInputs, AbuseIPDBEndpointOutputs } from './endpoints/types';
+import { AbuseIPDBSchema } from './schema';
+export type AbuseIPDBPluginOptions = {
+    /** Authentication method. Only api_key is supported. */
+    authType?: PickAuth<'api_key'>;
+    /**
+     * AbuseIPDB account API key (from the dashboard). Sent in the `Key`
+     * header on every request.
+     */
+    key?: string;
+    /** Optional: lifecycle hooks for endpoints */
+    hooks?: InternalAbuseIPDBPlugin['hooks'];
+    /** Optional: custom error handlers (merged with defaults) */
+    errorHandlers?: CorsairErrorHandler;
+    /**
+     * Permission configuration for the AbuseIPDB plugin. The read-only
+     * endpoints (check, reports, blacklist, check-block) default to 'open';
+     * the write endpoints (report, clear-address) default to 'allow'.
+     */
+    permissions?: PluginPermissionsConfig<typeof abuseIPDBEndpointsNested>;
+};
+export type AbuseIPDBContext = CorsairPluginContext<typeof AbuseIPDBSchema, AbuseIPDBPluginOptions, undefined, typeof abuseIPDBAuthConfig>;
+export type AbuseIPDBKeyBuilderContext = KeyBuilderContext<AbuseIPDBPluginOptions, typeof abuseIPDBAuthConfig>;
+export type AbuseIPDBBoundEndpoints = BindEndpoints<typeof abuseIPDBEndpointsNested>;
+type AbuseIPDBEndpoint<K extends keyof AbuseIPDBEndpointOutputs> = CorsairEndpoint<AbuseIPDBContext, AbuseIPDBEndpointInputs[K], AbuseIPDBEndpointOutputs[K]>;
+export type AbuseIPDBEndpoints = {
+    checkIp: AbuseIPDBEndpoint<'checkIp'>;
+    getReports: AbuseIPDBEndpoint<'getReports'>;
+    getBlacklist: AbuseIPDBEndpoint<'getBlacklist'>;
+    reportIp: AbuseIPDBEndpoint<'reportIp'>;
+    checkBlock: AbuseIPDBEndpoint<'checkBlock'>;
+    clearAddress: AbuseIPDBEndpoint<'clearAddress'>;
+};
+declare const abuseIPDBEndpointsNested: {
+    readonly check: {
+        readonly ip: AbuseIPDBEndpoint<"checkIp">;
+    };
+    readonly reports: {
+        readonly list: AbuseIPDBEndpoint<"getReports">;
+    };
+    readonly blacklist: {
+        readonly get: AbuseIPDBEndpoint<"getBlacklist">;
+    };
+    readonly report: {
+        readonly ip: AbuseIPDBEndpoint<"reportIp">;
+    };
+    readonly block: {
+        readonly check: AbuseIPDBEndpoint<"checkBlock">;
+    };
+    readonly address: {
+        readonly clear: AbuseIPDBEndpoint<"clearAddress">;
+    };
+};
+declare const abuseIPDBWebhooksNested: {};
+export declare const abuseIPDBEndpointSchemas: {
+    readonly 'check.ip': {
+        readonly input: import("zod").ZodObject<{
+            ipAddress: import("zod").ZodUnion<readonly [import("zod").ZodIPv4, import("zod").ZodIPv6]>;
+            maxAgeInDays: import("zod").ZodOptional<import("zod").ZodNumber>;
+            verbose: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            ipAddress: import("zod").ZodString;
+            isPublic: import("zod").ZodBoolean;
+            ipVersion: import("zod").ZodNumber;
+            isWhitelisted: import("zod").ZodNullable<import("zod").ZodBoolean>;
+            abuseConfidenceScore: import("zod").ZodNumber;
+            countryCode: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            countryName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            usageType: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            isp: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            domain: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            hostnames: import("zod").ZodArray<import("zod").ZodString>;
+            isTor: import("zod").ZodBoolean;
+            totalReports: import("zod").ZodNumber;
+            numDistinctUsers: import("zod").ZodNumber;
+            lastReportedAt: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            reports: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                reportedAt: import("zod").ZodString;
+                comment: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                categories: import("zod").ZodArray<import("zod").ZodNumber>;
+                reporterId: import("zod").ZodNumber;
+                reporterCountryCode: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                reporterCountryName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            }, import("zod/v4/core").$loose>>>;
+        }, import("zod/v4/core").$loose>;
+    };
+    readonly 'reports.list': {
+        readonly input: import("zod").ZodObject<{
+            ipAddress: import("zod").ZodUnion<readonly [import("zod").ZodIPv4, import("zod").ZodIPv6]>;
+            maxAgeInDays: import("zod").ZodOptional<import("zod").ZodNumber>;
+            page: import("zod").ZodOptional<import("zod").ZodNumber>;
+            perPage: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            total: import("zod").ZodNumber;
+            page: import("zod").ZodNumber;
+            count: import("zod").ZodNumber;
+            perPage: import("zod").ZodNumber;
+            lastPage: import("zod").ZodNumber;
+            nextPageUrl: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            previousPageUrl: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            results: import("zod").ZodArray<import("zod").ZodObject<{
+                reportedAt: import("zod").ZodString;
+                comment: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                categories: import("zod").ZodArray<import("zod").ZodNumber>;
+                reporterId: import("zod").ZodNumber;
+                reporterCountryCode: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                reporterCountryName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            }, import("zod/v4/core").$loose>>;
+        }, import("zod/v4/core").$loose>;
+    };
+    readonly 'blacklist.get': {
+        readonly input: import("zod").ZodObject<{
+            confidenceMinimum: import("zod").ZodOptional<import("zod").ZodNumber>;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            onlyCountries: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            exceptCountries: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            ipVersion: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<4>, import("zod").ZodLiteral<6>]>>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            generatedAt: import("zod").ZodString;
+            entries: import("zod").ZodArray<import("zod").ZodObject<{
+                ipAddress: import("zod").ZodString;
+                abuseConfidenceScore: import("zod").ZodNumber;
+                lastReportedAt: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                countryCode: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            }, import("zod/v4/core").$loose>>;
+        }, import("zod/v4/core").$strip>;
+    };
+    readonly 'report.ip': {
+        readonly input: import("zod").ZodObject<{
+            ip: import("zod").ZodUnion<readonly [import("zod").ZodIPv4, import("zod").ZodIPv6]>;
+            categories: import("zod").ZodArray<import("zod").ZodNumber>;
+            comment: import("zod").ZodOptional<import("zod").ZodString>;
+            timestamp: import("zod").ZodOptional<import("zod").ZodISODateTime>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            ipAddress: import("zod").ZodString;
+            abuseConfidenceScore: import("zod").ZodNumber;
+        }, import("zod/v4/core").$loose>;
+    };
+    readonly 'block.check': {
+        readonly input: import("zod").ZodObject<{
+            network: import("zod").ZodUnion<readonly [import("zod").ZodCIDRv4, import("zod").ZodCIDRv6]>;
+            maxAgeInDays: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            networkAddress: import("zod").ZodString;
+            netmask: import("zod").ZodString;
+            minAddress: import("zod").ZodString;
+            maxAddress: import("zod").ZodString;
+            numPossibleHosts: import("zod").ZodNumber;
+            addressSpaceDesc: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            reportedAddress: import("zod").ZodArray<import("zod").ZodObject<{
+                ipAddress: import("zod").ZodString;
+                numReports: import("zod").ZodNumber;
+                mostRecentReport: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                abuseConfidenceScore: import("zod").ZodNumber;
+                countryCode: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            }, import("zod/v4/core").$loose>>;
+        }, import("zod/v4/core").$loose>;
+    };
+    readonly 'address.clear': {
+        readonly input: import("zod").ZodObject<{
+            ipAddress: import("zod").ZodUnion<readonly [import("zod").ZodIPv4, import("zod").ZodIPv6]>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            numReportsDeleted: import("zod").ZodNumber;
+        }, import("zod/v4/core").$loose>;
+    };
+};
+declare const defaultAuthType: "api_key";
+export declare const abuseIPDBAuthConfig: {
+    readonly api_key: {
+        readonly account: readonly [];
+    };
+};
+export type BaseAbuseIPDBPlugin<T extends AbuseIPDBPluginOptions> = CorsairPlugin<'abuseipdb', typeof AbuseIPDBSchema, typeof abuseIPDBEndpointsNested, typeof abuseIPDBWebhooksNested, T, typeof defaultAuthType, typeof abuseIPDBAuthConfig>;
+export type InternalAbuseIPDBPlugin = BaseAbuseIPDBPlugin<AbuseIPDBPluginOptions>;
+export type ExternalAbuseIPDBPlugin<T extends AbuseIPDBPluginOptions> = BaseAbuseIPDBPlugin<T>;
+export declare function abuseipdb<const T extends AbuseIPDBPluginOptions>(incomingOptions?: AbuseIPDBPluginOptions & T): ExternalAbuseIPDBPlugin<T>;
+export type { AbuseIPDBEndpointInputs, AbuseIPDBEndpointOutputs, CheckBlockInput, CheckBlockResponse, CheckIpInput, CheckIpResponse, ClearAddressInput, ClearAddressResponse, GetBlacklistInput, GetBlacklistResponse, GetReportsInput, GetReportsResponse, ReportIpInput, ReportIpResponse, } from './endpoints/types';
+export { CheckBlockInputSchema, CheckBlockResponseSchema, CheckIpInputSchema, CheckIpResponseSchema, ClearAddressInputSchema, ClearAddressResponseSchema, GetBlacklistInputSchema, GetBlacklistResponseSchema, GetReportsInputSchema, GetReportsResponseSchema, ReportIpInputSchema, ReportIpResponseSchema, } 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,EAEX,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,QAAQ,EAER,uBAAuB,EAGvB,MAAM,cAAc,CAAC;AAWtB,OAAO,KAAK,EACX,uBAAuB,EACvB,wBAAwB,EACxB,MAAM,mBAAmB,CAAC;AAM3B,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAM3C,MAAM,MAAM,sBAAsB,GAAG;IACpC,wDAAwD;IACxD,QAAQ,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC/B;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,KAAK,CAAC,EAAE,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACzC,6DAA6D;IAC7D,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC;;;;OAIG;IACH,WAAW,CAAC,EAAE,uBAAuB,CAAC,OAAO,wBAAwB,CAAC,CAAC;CACvE,CAAC;AAMF,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,CAClD,OAAO,eAAe,EACtB,sBAAsB,EACtB,SAAS,EACT,OAAO,mBAAmB,CAC1B,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,iBAAiB,CACzD,sBAAsB,EACtB,OAAO,mBAAmB,CAC1B,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAClD,OAAO,wBAAwB,CAC/B,CAAC;AAEF,KAAK,iBAAiB,CAAC,CAAC,SAAS,MAAM,wBAAwB,IAC9D,eAAe,CACd,gBAAgB,EAChB,uBAAuB,CAAC,CAAC,CAAC,EAC1B,wBAAwB,CAAC,CAAC,CAAC,CAC3B,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG;IAChC,OAAO,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAC;IACtC,UAAU,EAAE,iBAAiB,CAAC,YAAY,CAAC,CAAC;IAC5C,YAAY,EAAE,iBAAiB,CAAC,cAAc,CAAC,CAAC;IAChD,QAAQ,EAAE,iBAAiB,CAAC,UAAU,CAAC,CAAC;IACxC,UAAU,EAAE,iBAAiB,CAAC,YAAY,CAAC,CAAC;IAC5C,YAAY,EAAE,iBAAiB,CAAC,cAAc,CAAC,CAAC;CAChD,CAAC;AAMF,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;CAmBpB,CAAC;AAGX,QAAA,MAAM,uBAAuB,IAAc,CAAC;AAM5C,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BpC,CAAC;AA6CF,QAAA,MAAM,eAAe,WAAyC,CAAC;AAE/D,eAAO,MAAM,mBAAmB;;;;CAIK,CAAC;AAMtC,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,sBAAsB,IAC/D,aAAa,CACZ,WAAW,EACX,OAAO,eAAe,EACtB,OAAO,wBAAwB,EAC/B,OAAO,uBAAuB,EAC9B,CAAC,EACD,OAAO,eAAe,EACtB,OAAO,mBAAmB,CAC1B,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAClC,mBAAmB,CAAC,sBAAsB,CAAC,CAAC;AAE7C,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,sBAAsB,IACnE,mBAAmB,CAAC,CAAC,CAAC,CAAC;AAMxB,wBAAgB,SAAS,CAAC,KAAK,CAAC,CAAC,SAAS,sBAAsB,EAC/D,eAAe,GAAE,sBAAsB,GAItC,CAAoC,GACnC,uBAAuB,CAAC,CAAC,CAAC,CAsC5B;AAMD,YAAY,EACX,uBAAuB,EACvB,wBAAwB,EACxB,eAAe,EACf,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,EACjB,oBAAoB,EACpB,eAAe,EACf,kBAAkB,EAClB,aAAa,EACb,gBAAgB,GAChB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACN,qBAAqB,EACrB,wBAAwB,EACxB,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,EACvB,0BAA0B,EAC1B,uBAAuB,EACvB,0BAA0B,EAC1B,qBAAqB,EACrB,wBAAwB,EACxB,mBAAmB,EACnB,sBAAsB,GACtB,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+import{AuthMissingError as Be}from"corsair/core";import{ApiError as E,request as ee}from"corsair/http";var l=class extends Error{constructor(n,s,o){super(n,o);this.code=s;this.name="AbuseIPDBAPIError",o?.cause instanceof E&&(this.status=o.cause.status,this.statusText=o.cause.statusText,this.body=o.cause.body,this.retryAfter=o.cause.retryAfter,this.rateLimitReset=o.cause.rateLimitReset,this.rateLimitRemaining=o.cause.rateLimitRemaining,this.rateLimitLimit=o.cause.rateLimitLimit)}status;statusText;body;retryAfter;rateLimitReset;rateLimitRemaining;rateLimitLimit},te=/no dek found/i;async function C(t){try{return await t()??void 0}catch(r){if(r instanceof Error&&te.test(r.message))return;throw r}}var re="https://api.abuseipdb.com/api/v2",B=6,se={enabled:!0,maxRetries:0,initialRetryDelay:0,backoffMultiplier:1,headerNames:{retryAfter:"retry-after"}},oe=3e4;function ne(t){return!(t instanceof l)||t.status===void 0?!1:t.status>=500}function ie(t,r){let n=typeof t.retryAfter=="number"&&t.retryAfter>=0?t.retryAfter:2**r*1e3;return Math.min(n,oe)}async function p(t,r,n={}){let{method:s="GET",query:o,formBody:g,retries:X=s==="GET"}=n,Z={BASE:re,VERSION:"2.0.0",WITH_CREDENTIALS:!1,CREDENTIALS:"omit",TOKEN:void 0,HEADERS:{Key:r}},Q={method:s,url:t,query:o,body:g?new URLSearchParams(Object.entries(g).filter(([,a])=>a!==void 0).map(([a,d])=>[a,String(d)])).toString():void 0,mediaType:g?"application/x-www-form-urlencoded":void 0},R=async()=>{try{return await ee(Z,Q,{rateLimitConfig:se})}catch(a){throw a instanceof E?new l(a.message,a.status,{cause:a}):a instanceof Error?new l(a.message,void 0,{cause:a}):new l("Unknown error")}};if(!X)return await R();let P;for(let a=0;a<B;a++)try{return await R()}catch(d){if(P=d,!ne(d)||a===B-1)throw d;await new Promise(J=>setTimeout(J,ie(d,a)))}throw P}import{AuthMissingError as ue,logEventFromContext as de}from"corsair/core";import{z as le}from"zod";import{z as e}from"zod";var b=e.union([e.ipv4(),e.ipv6()]),D=e.object({ipAddress:b.describe("IPv4 or IPv6 address to check"),maxAgeInDays:e.number().int().min(1).max(365).optional().describe("Only consider reports from the last N days (1\u2013365)"),verbose:e.boolean().optional().describe("Include the full reports array")}),x=e.object({reportedAt:e.string(),comment:e.string().nullable().optional(),categories:e.array(e.number()),reporterId:e.number(),reporterCountryCode:e.string().nullable().optional(),reporterCountryName:e.string().nullable().optional()}).loose(),I=e.object({ipAddress:e.string(),isPublic:e.boolean(),ipVersion:e.number(),isWhitelisted:e.boolean().nullable(),abuseConfidenceScore:e.number(),countryCode:e.string().nullable().optional(),countryName:e.string().nullable().optional(),usageType:e.string().nullable().optional(),isp:e.string().nullable().optional(),domain:e.string().nullable().optional(),hostnames:e.array(e.string()),isTor:e.boolean(),totalReports:e.number(),numDistinctUsers:e.number(),lastReportedAt:e.string().nullable().optional(),reports:e.array(x).optional()}).loose(),S=e.object({ipAddress:b.describe("IPv4 or IPv6 address to fetch reports for"),maxAgeInDays:e.number().int().min(1).max(365).optional().describe("Only consider reports from the last N days (1\u2013365)"),page:e.number().int().min(1).optional().describe("Page number (starts at 1)"),perPage:e.number().int().min(1).max(100).optional().describe("Reports per page (1\u2013100)")}),ae=x,h=e.object({total:e.number(),page:e.number(),count:e.number(),perPage:e.number(),lastPage:e.number(),nextPageUrl:e.string().nullable().optional(),previousPageUrl:e.string().nullable().optional(),results:e.array(ae)}).loose(),w=e.object({confidenceMinimum:e.number().int().min(25).max(100).optional().describe("Minimum abuse confidence score (25\u2013100)"),limit:e.number().int().min(1).max(5e5).optional().describe("Maximum number of entries to return"),onlyCountries:e.array(e.string().regex(/^[A-Za-z]{2}$/)).optional().describe("Only include IPs from these ISO 3166 alpha-2 country codes"),exceptCountries:e.array(e.string().regex(/^[A-Za-z]{2}$/)).optional().describe("Exclude IPs from these ISO 3166 alpha-2 country codes"),ipVersion:e.union([e.literal(4),e.literal(6)]).optional().describe("Restrict to a single IP version (4 or 6)")}),pe=e.object({ipAddress:e.string(),abuseConfidenceScore:e.number(),lastReportedAt:e.string().nullable().optional(),countryCode:e.string().nullable().optional()}).loose(),y=e.object({generatedAt:e.string(),entries:e.array(pe)}),T=e.object({ip:b.describe("IPv4 or IPv6 address being reported"),categories:e.array(e.number().int().min(1).max(30)).min(1).describe("Abuse category IDs (integers 1\u201330)"),comment:e.string().optional().describe("Descriptive text of the attack; avoid any PII"),timestamp:e.iso.datetime({offset:!0}).optional().describe("ISO 8601 datetime of the attack, defaults to now")}),f=e.object({ipAddress:e.string(),abuseConfidenceScore:e.number()}).loose(),v=e.object({network:e.union([e.cidrv4(),e.cidrv6()]).describe('CIDR notation network block, e.g. "127.0.0.1/24"'),maxAgeInDays:e.number().int().min(1).max(365).optional().describe("Only consider reports from the last N days (1\u2013365)")}),ce=e.object({ipAddress:e.string(),numReports:e.number(),mostRecentReport:e.string().nullable().optional(),abuseConfidenceScore:e.number(),countryCode:e.string().nullable().optional()}).loose(),k=e.object({networkAddress:e.string(),netmask:e.string(),minAddress:e.string(),maxAddress:e.string(),numPossibleHosts:e.number(),addressSpaceDesc:e.string().nullable().optional(),reportedAddress:e.array(ce)}).loose(),O=e.object({ipAddress:b.describe("IPv4 or IPv6 address to clear reports for")}),A=e.object({numReportsDeleted:e.number()}).loose(),c={checkIp:D,getReports:S,getBlacklist:w,reportIp:T,checkBlock:v,clearAddress:O},u={checkIp:I,getReports:h,getBlacklist:y,reportIp:f,checkBlock:k,clearAddress:A};var L=async(t,r)=>{if(!t.key)throw new ue("abuseipdb","api_key");let n=await p("blacklist",t.key,{query:{confidenceMinimum:r.confidenceMinimum,limit:r.limit,onlyCountries:r.onlyCountries?.join(","),exceptCountries:r.exceptCountries?.join(","),ipVersion:r.ipVersion}}),s=le.string().parse(n.meta?.generatedAt),o=y.parse({generatedAt:s,entries:n.data});return await de(t,"abuseipdb.blacklist.get",{confidenceMinimum:r.confidenceMinimum??100,limit:r.limit},"completed"),o};import{AuthMissingError as me,logEventFromContext as be}from"corsair/core";var G=async(t,r)=>{if(!t.key)throw new me("abuseipdb","api_key");let n=await p("check",t.key,{query:{ipAddress:r.ipAddress,maxAgeInDays:r.maxAgeInDays,verbose:r.verbose?"":void 0}}),s=I.parse(n.data);if(t.db?.ipChecks)try{await t.db.ipChecks.upsertByEntityId(s.ipAddress,{ipAddress:s.ipAddress,abuseConfidenceScore:s.abuseConfidenceScore,isPublic:s.isPublic,ipVersion:s.ipVersion,countryCode:s.countryCode??null,countryName:s.countryName??null,usageType:s.usageType??null,isp:s.isp??null,domain:s.domain??null,isTor:s.isTor,totalReports:s.totalReports,numDistinctUsers:s.numDistinctUsers,checkedAt:new Date})}catch(o){console.warn("Failed to save IP check result to database:",o)}return await be(t,"abuseipdb.check.ip",{ipAddress:r.ipAddress},"completed"),s};import{AuthMissingError as Ie,logEventFromContext as he}from"corsair/core";var _=async(t,r)=>{if(!t.key)throw new Ie("abuseipdb","api_key");let n=await p("check-block",t.key,{query:{network:r.network,maxAgeInDays:r.maxAgeInDays}}),s=k.parse(n.data);return await he(t,"abuseipdb.block.check",{network:r.network},"completed"),s};import{AuthMissingError as ye,logEventFromContext as fe}from"corsair/core";var M=async(t,r)=>{if(!t.key)throw new ye("abuseipdb","api_key");let n=await p("clear-address",t.key,{method:"DELETE",query:{ipAddress:r.ipAddress}}),s=A.parse(n.data);if(t.db?.reports)try{await t.db.reports.deleteByEntityId(r.ipAddress)}catch(o){console.warn("Failed to remove report from database:",o)}if(t.db?.ipChecks)try{await t.db.ipChecks.deleteByEntityId(r.ipAddress)}catch(o){console.warn("Failed to remove IP check from database:",o)}return await fe(t,"abuseipdb.address.clear",{ipAddress:r.ipAddress},"completed"),s};import{AuthMissingError as ke,logEventFromContext as Ae}from"corsair/core";var q=async(t,r)=>{if(!t.key)throw new ke("abuseipdb","api_key");let n=await p("report",t.key,{method:"POST",formBody:{ip:r.ip,categories:r.categories.join(","),comment:r.comment,timestamp:r.timestamp}}),s=f.parse(n.data);if(t.db?.reports)try{await t.db.reports.upsertByEntityId(s.ipAddress,{ipAddress:s.ipAddress,abuseConfidenceScore:s.abuseConfidenceScore,reportedAt:new Date})}catch(o){console.warn("Failed to save report to database:",o)}return await Ae(t,"abuseipdb.report.ip",{ip:r.ip,categories:r.categories.join(",")},"completed"),s};import{AuthMissingError as ge,logEventFromContext as Re}from"corsair/core";var N=async(t,r)=>{if(!t.key)throw new ge("abuseipdb","api_key");let n=await p("reports",t.key,{query:{ipAddress:r.ipAddress,maxAgeInDays:r.maxAgeInDays,page:r.page,perPage:r.perPage}}),s=h.parse(n.data);return await Re(t,"abuseipdb.reports.list",{ipAddress:r.ipAddress,page:r.page??1},"completed"),s};var j={check:G},z={list:N},U={get:L},H={report:q},K={check:_},F={clear:M};function m(t){return t.status}function Pe(t){return t.retryAfter}var V={RATE_LIMIT_ERROR:{match:t=>{if(m(t)===429)return!0;let r=t.message.toLowerCase();return r.includes("429")||r.includes("rate limit")},handler:async t=>({maxRetries:0,headersRetryAfterMs:Pe(t)})},AUTH_ERROR:{match:t=>{if(m(t)===401)return!0;let r=t.message.toLowerCase();return r.includes("unauthorized")||r.includes("invalid api key")||r.includes("401")},handler:async()=>(console.warn("[ABUSEIPDB] Authentication failed \u2014 check that the API key is valid and active on your AbuseIPDB account."),{maxRetries:0})},PAYMENT_REQUIRED_ERROR:{match:t=>{if(m(t)===402)return!0;let r=t.message.toLowerCase();return r.includes("402")||r.includes("payment required")},handler:async()=>(console.warn("[ABUSEIPDB] Request rejected \u2014 the parameter exceeds your current plan tier (e.g. check-block network too large). Upgrade the plan or narrow the request."),{maxRetries:0})},VALIDATION_ERROR:{match:t=>{if(m(t)===422)return!0;let r=t.message.toLowerCase();return r.includes("422")||r.includes("unprocessable")},handler:async()=>(console.warn("[ABUSEIPDB] Request rejected \u2014 a parameter is missing, malformed, or out of range (see the error detail for the offending field)."),{maxRetries:0})},SERVER_ERROR:{match:t=>{let r=m(t);if(r!==void 0&&r>=500)return!0;let n=t.message.toLowerCase();return n.includes("500")||n.includes("internal server error")},handler:async()=>({maxRetries:0})},DEFAULT:{match:()=>!0,handler:async t=>(console.error(`[ABUSEIPDB] Unhandled error: ${t.message}`),{maxRetries:0})}};import{z as i}from"zod";var W=i.object({ipAddress:i.string(),abuseConfidenceScore:i.number(),isPublic:i.boolean(),ipVersion:i.number(),countryCode:i.string().nullable().optional(),countryName:i.string().nullable().optional(),usageType:i.string().nullable().optional(),isp:i.string().nullable().optional(),domain:i.string().nullable().optional(),isTor:i.boolean(),totalReports:i.number(),numDistinctUsers:i.number(),checkedAt:i.coerce.date().nullable().optional()}),Y=i.object({ipAddress:i.string(),abuseConfidenceScore:i.number(),reportedAt:i.coerce.date().nullable().optional()});var $={version:"1.0.0",entities:{ipChecks:W,reports:Y}};var Ee={check:{ip:j.check},reports:{list:z.list},blacklist:{get:U.get},report:{ip:H.report},block:{check:K.check},address:{clear:F.clear}},Ce={},De={"check.ip":{input:c.checkIp,output:u.checkIp},"reports.list":{input:c.getReports,output:u.getReports},"blacklist.get":{input:c.getBlacklist,output:u.getBlacklist},"report.ip":{input:c.reportIp,output:u.reportIp},"block.check":{input:c.checkBlock,output:u.checkBlock},"address.clear":{input:c.clearAddress,output:u.clearAddress}},xe={"check.ip":{riskLevel:"read",description:"Look up an IP address and get its abuse confidence score, country, ISP, usage type, and optionally recent reports"},"reports.list":{riskLevel:"read",description:"Get a paginated list of abuse reports filed against a single IP address"},"blacklist.get":{riskLevel:"read",description:"Download the blacklist of most-reported IPs, optionally filtered by confidence minimum, country, and IP version"},"report.ip":{riskLevel:"write",description:"Submit an abuse report for an IP address with one or more abuse category IDs"},"block.check":{riskLevel:"read",description:"Check a CIDR network block and list the reported addresses within it"},"address.clear":{riskLevel:"destructive",description:"Remove all reports for an IP address from your account and return the number deleted"}},Se="api_key",we={api_key:{account:[]}};function Et(t={}){let r={...t,authType:t.authType??Se};return{id:"abuseipdb",authConfig:we,schema:$,options:r,hooks:r.hooks,webhookHooks:void 0,endpoints:Ee,webhooks:Ce,endpointMeta:xe,endpointSchemas:De,pluginWebhookMatcher:void 0,errorHandlers:{...V,...r.errorHandlers},keyBuilder:async(n,s)=>{if(s==="endpoint"&&r.key)return r.key;if(s==="endpoint"){let o=await C(()=>n.keys?.get_api_key());if(!o)throw new Be("abuseipdb","api_key");return o}return""}}}export{v as CheckBlockInputSchema,k as CheckBlockResponseSchema,D as CheckIpInputSchema,I as CheckIpResponseSchema,O as ClearAddressInputSchema,A as ClearAddressResponseSchema,w as GetBlacklistInputSchema,y as GetBlacklistResponseSchema,S as GetReportsInputSchema,h as GetReportsResponseSchema,T as ReportIpInputSchema,f as ReportIpResponseSchema,we as abuseIPDBAuthConfig,De as abuseIPDBEndpointSchemas,Et as abuseipdb};

package/dist/integration.test.d.ts

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

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

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

package/dist/operations.test.d.ts

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

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

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

package/dist/schema/database.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const AbuseIPDBIpCheck: z.ZodObject<{
+    ipAddress: z.ZodString;
+    abuseConfidenceScore: z.ZodNumber;
+    isPublic: z.ZodBoolean;
+    ipVersion: z.ZodNumber;
+    countryCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    countryName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    usageType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isp: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    domain: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isTor: z.ZodBoolean;
+    totalReports: z.ZodNumber;
+    numDistinctUsers: z.ZodNumber;
+    checkedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+}, z.core.$strip>;
+export declare const AbuseIPDBReport: z.ZodObject<{
+    ipAddress: z.ZodString;
+    abuseConfidenceScore: z.ZodNumber;
+    reportedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+}, z.core.$strip>;
+export type AbuseIPDBIpCheck = z.infer<typeof AbuseIPDBIpCheck>;
+export type AbuseIPDBReport = z.infer<typeof AbuseIPDBReport>;
+//# sourceMappingURL=database.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../schema/database.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;iBAc3B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;iBAI1B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAChE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/schema/index.d.ts

@@ -0,0 +1,26 @@
+export declare const AbuseIPDBSchema: {
+    readonly version: "1.0.0";
+    readonly entities: {
+        readonly ipChecks: import("zod").ZodObject<{
+            ipAddress: import("zod").ZodString;
+            abuseConfidenceScore: import("zod").ZodNumber;
+            isPublic: import("zod").ZodBoolean;
+            ipVersion: import("zod").ZodNumber;
+            countryCode: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            countryName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            usageType: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            isp: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            domain: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            isTor: import("zod").ZodBoolean;
+            totalReports: import("zod").ZodNumber;
+            numDistinctUsers: import("zod").ZodNumber;
+            checkedAt: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodCoercedDate<unknown>>>;
+        }, import("zod/v4/core").$strip>;
+        readonly reports: import("zod").ZodObject<{
+            ipAddress: import("zod").ZodString;
+            abuseConfidenceScore: import("zod").ZodNumber;
+            reportedAt: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodCoercedDate<unknown>>>;
+        }, import("zod/v4/core").$strip>;
+    };
+};
+//# 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,eAAe;;;;;;;;;;;;;;;;;;;;;;;;CAMlB,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/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

@@ -0,0 +1,44 @@
+{
+  "name": "@corsair-dev/abuseipdb",
+  "version": "0.1.0",
+  "description": "AbuseIPDB plugin for Corsair",
+  "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.120"
+  },
+  "keywords": [
+    "corsair",
+    "abuseipdb",
+    "plugin"
+  ],
+  "author": "",
+  "license": "Apache-2.0",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc --build --force && tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "jest"
+  }
+}