@corsair-dev/addresszen 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 @@
+import 'dotenv/config';
+//# 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":"AAAA,OAAO,eAAe,CAAC"}

package/dist/client.d.ts

@@ -0,0 +1,25 @@
+export declare class AddresszenAPIError extends Error {
+    readonly code?: number | undefined;
+    readonly status?: number;
+    readonly statusText?: string;
+    readonly body?: unknown;
+    readonly retryAfter?: number;
+    constructor(message: string, code?: number | undefined, options?: {
+        cause?: Error;
+    });
+}
+/**
+ * Performs a request to the Addresszen API.
+ *
+ * Auth: API key passed via the Authorization header to avoid leaking credentials
+ * into URL access logs. Addresszen also supports query-string auth, but header
+ * auth is preferred per their API reference.
+ */
+export declare function makeAddresszenRequest<T>(endpoint: string, apiKey: string, options?: {
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    body?: Record<string, unknown>;
+    query?: Record<string, string | number | boolean | undefined>;
+    /** When false, skip Authorization (public endpoints that identify the key in the path). */
+    auth?: 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":"AAGA,qBAAa,kBAAmB,SAAQ,KAAK;aAU3B,IAAI,CAAC,EAAE,MAAM;IAT9B,SAAgB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChC,SAAgB,UAAU,CAAC,EAAE,MAAM,CAAC;IAGpC,SAAgB,IAAI,CAAC,EAAE,OAAO,CAAC;IAC/B,SAAgB,UAAU,CAAC,EAAE,MAAM,CAAC;gBAGnC,OAAO,EAAE,MAAM,EACC,IAAI,CAAC,EAAE,MAAM,YAAA,EAC7B,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE;CAY5B;AAID;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CAAC,CAAC,EAC5C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IACR,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC;IACrD,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,CAAC;IAC9D,2FAA2F;IAC3F,IAAI,CAAC,EAAE,OAAO,CAAC;CACV,GACJ,OAAO,CAAC,CAAC,CAAC,CAuCZ"}

package/dist/endpoints/autocomplete.d.ts

@@ -0,0 +1,9 @@
+import type { AddresszenEndpoints } from '../index';
+/**
+ * Get address autocomplete suggestions for a partial query.
+ *
+ * API: GET /autocomplete/addresses
+ * Docs: https://docs.addresszen.com/docs/api/find-address
+ */
+export declare const addresses: AddresszenEndpoints['autocompleteAddresses'];
+//# sourceMappingURL=autocomplete.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"autocomplete.d.ts","sourceRoot":"","sources":["../../endpoints/autocomplete.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAGpD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,mBAAmB,CAAC,uBAAuB,CAwClE,CAAC"}

package/dist/endpoints/index.d.ts

@@ -0,0 +1,83 @@
+export declare const Autocomplete: {
+    addresses: (ctx: import("..").AddresszenContext, args: {
+        query: string;
+        limit?: number | undefined;
+        page?: number | undefined;
+    }) => Promise<{
+        code: number;
+        message: string;
+        result: {
+            [x: string]: unknown;
+            hits: {
+                [x: string]: unknown;
+                id: string;
+                suggestion: string;
+                urls?: Record<string, unknown> | null | undefined;
+                udprn?: number | undefined;
+            }[];
+        };
+    }>;
+};
+export declare const Verify: {
+    address: (ctx: import("..").AddresszenContext, args: {
+        query: string;
+        zip_code?: string | undefined;
+        city?: string | undefined;
+        state?: string | undefined;
+        context?: string | undefined;
+    }) => Promise<{
+        code: number;
+        message: string;
+        result: {
+            [x: string]: unknown;
+            query: string;
+            query_city?: string | undefined;
+            query_state?: string | undefined;
+            query_zip_code?: string | undefined;
+            match?: unknown;
+            count?: number | undefined;
+            fit?: number | undefined;
+            confidence?: number | undefined;
+            match_information?: unknown;
+            address_line_one?: string | undefined;
+            address_line_two?: string | undefined;
+            city?: string | undefined;
+            state?: string | undefined;
+            zip_code?: string | undefined;
+            country_iso_2?: string | undefined;
+        };
+    }>;
+};
+export declare const Key: {
+    availability: (ctx: import("..").AddresszenContext, args: Record<string, never>) => Promise<{
+        code: number;
+        message: string;
+        result: {
+            [x: string]: unknown;
+            available: boolean;
+            context?: string | undefined;
+            contexts?: Record<string, unknown>[] | undefined;
+        };
+    }>;
+};
+export declare const Resolve: {
+    addressUsa: (ctx: import("..").AddresszenContext, args: {
+        addressId: string;
+    }) => Promise<{
+        code: number;
+        message: string;
+        result: {
+            [x: string]: unknown;
+            id?: string | undefined;
+            line_1?: string | undefined;
+            line_2?: string | undefined;
+            city?: string | undefined;
+            state?: string | undefined;
+            state_abbreviation?: string | undefined;
+            zip_code?: string | undefined;
+            country_iso_2?: string | undefined;
+        };
+    }>;
+};
+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":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;CAExB,CAAC;AAEF,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAElB,CAAC;AAEF,eAAO,MAAM,GAAG;;;;;;;;;;;CAEf,CAAC;AAEF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;CAEnB,CAAC;AAEF,cAAc,SAAS,CAAC"}

package/dist/endpoints/key.d.ts

@@ -0,0 +1,13 @@
+import type { AddresszenEndpoints } from '../index';
+/**
+ * Get public information on an API key, including whether it is usable.
+ *
+ * API: GET /keys/:key
+ * Docs: https://docs.addresszen.com/docs/api/key-availability
+ *
+ * Addresszen requires the key as the path resource id for this public endpoint;
+ * there is no header-only variant. Auth header is omitted so the credential is
+ * not also sent in Authorization.
+ */
+export declare const availability: AddresszenEndpoints['keyAvailability'];
+//# sourceMappingURL=key.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../endpoints/key.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAGpD;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,EAAE,mBAAmB,CAAC,iBAAiB,CAqC/D,CAAC"}

package/dist/endpoints/resolve.d.ts

@@ -0,0 +1,9 @@
+import type { AddresszenEndpoints } from '../index';
+/**
+ * Resolve an address autocompletion by ID and return the full US-format address.
+ *
+ * API: GET /autocomplete/addresses/:address/usa
+ * Docs: https://docs.addresszen.com/docs/api/retrieve-address
+ */
+export declare const addressUsa: AddresszenEndpoints['resolveAddressUsa'];
+//# sourceMappingURL=resolve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../endpoints/resolve.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAGpD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,mBAAmB,CAAC,mBAAmB,CAqC/D,CAAC"}

package/dist/endpoints/types.d.ts

@@ -0,0 +1,178 @@
+import { z } from 'zod';
+declare const AddressSuggestionSchema: z.ZodObject<{
+    id: z.ZodString;
+    suggestion: z.ZodString;
+    urls: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    udprn: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export type AddressSuggestion = z.infer<typeof AddressSuggestionSchema>;
+export declare const AutocompleteAddressesInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type AutocompleteAddressesInput = z.infer<typeof AutocompleteAddressesInputSchema>;
+export declare const AutocompleteAddressesResponseSchema: z.ZodObject<{
+    code: z.ZodNumber;
+    message: z.ZodString;
+    result: z.ZodObject<{
+        hits: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            suggestion: z.ZodString;
+            urls: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            udprn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export type AutocompleteAddressesResponse = z.infer<typeof AutocompleteAddressesResponseSchema>;
+export declare const VerifyAddressInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    zip_code: z.ZodOptional<z.ZodString>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type VerifyAddressInput = z.infer<typeof VerifyAddressInputSchema>;
+export declare const VerifyAddressResponseSchema: z.ZodObject<{
+    code: z.ZodNumber;
+    message: z.ZodString;
+    result: z.ZodObject<{
+        query: z.ZodString;
+        query_city: z.ZodOptional<z.ZodString>;
+        query_state: z.ZodOptional<z.ZodString>;
+        query_zip_code: z.ZodOptional<z.ZodString>;
+        match: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+        count: z.ZodOptional<z.ZodNumber>;
+        fit: z.ZodOptional<z.ZodNumber>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        match_information: z.ZodOptional<z.ZodUnknown>;
+        address_line_one: z.ZodOptional<z.ZodString>;
+        address_line_two: z.ZodOptional<z.ZodString>;
+        city: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodString>;
+        zip_code: z.ZodOptional<z.ZodString>;
+        country_iso_2: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export type VerifyAddressResponse = z.infer<typeof VerifyAddressResponseSchema>;
+export declare const KeyAvailabilityInputSchema: z.ZodObject<{}, z.core.$strip>;
+export type KeyAvailabilityInput = z.infer<typeof KeyAvailabilityInputSchema>;
+export declare const KeyAvailabilityResponseSchema: z.ZodObject<{
+    code: z.ZodNumber;
+    message: z.ZodString;
+    result: z.ZodObject<{
+        available: z.ZodBoolean;
+        context: z.ZodOptional<z.ZodString>;
+        contexts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export type KeyAvailabilityResponse = z.infer<typeof KeyAvailabilityResponseSchema>;
+export declare const ResolveAddressUsaInputSchema: z.ZodObject<{
+    addressId: z.ZodString;
+}, z.core.$strip>;
+export type ResolveAddressUsaInput = z.infer<typeof ResolveAddressUsaInputSchema>;
+export declare const ResolveAddressUsaResponseSchema: z.ZodObject<{
+    code: z.ZodNumber;
+    message: z.ZodString;
+    result: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        line_1: z.ZodOptional<z.ZodString>;
+        line_2: z.ZodOptional<z.ZodString>;
+        city: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodString>;
+        state_abbreviation: z.ZodOptional<z.ZodString>;
+        zip_code: z.ZodOptional<z.ZodString>;
+        country_iso_2: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export type ResolveAddressUsaResponse = z.infer<typeof ResolveAddressUsaResponseSchema>;
+export type AddresszenEndpointInputs = {
+    autocompleteAddresses: AutocompleteAddressesInput;
+    verifyAddress: VerifyAddressInput;
+    keyAvailability: KeyAvailabilityInput;
+    resolveAddressUsa: ResolveAddressUsaInput;
+};
+export type AddresszenEndpointOutputs = {
+    autocompleteAddresses: AutocompleteAddressesResponse;
+    verifyAddress: VerifyAddressResponse;
+    keyAvailability: KeyAvailabilityResponse;
+    resolveAddressUsa: ResolveAddressUsaResponse;
+};
+export declare const AddresszenEndpointInputSchemas: {
+    readonly autocompleteAddresses: z.ZodObject<{
+        query: z.ZodString;
+        limit: z.ZodOptional<z.ZodNumber>;
+        page: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly verifyAddress: z.ZodObject<{
+        query: z.ZodString;
+        zip_code: z.ZodOptional<z.ZodString>;
+        city: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodString>;
+        context: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly keyAvailability: z.ZodObject<{}, z.core.$strip>;
+    readonly resolveAddressUsa: z.ZodObject<{
+        addressId: z.ZodString;
+    }, z.core.$strip>;
+};
+export declare const AddresszenEndpointOutputSchemas: {
+    readonly autocompleteAddresses: z.ZodObject<{
+        code: z.ZodNumber;
+        message: z.ZodString;
+        result: z.ZodObject<{
+            hits: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                suggestion: z.ZodString;
+                urls: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+                udprn: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
+    }, z.core.$strip>;
+    readonly verifyAddress: z.ZodObject<{
+        code: z.ZodNumber;
+        message: z.ZodString;
+        result: z.ZodObject<{
+            query: z.ZodString;
+            query_city: z.ZodOptional<z.ZodString>;
+            query_state: z.ZodOptional<z.ZodString>;
+            query_zip_code: z.ZodOptional<z.ZodString>;
+            match: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+            count: z.ZodOptional<z.ZodNumber>;
+            fit: z.ZodOptional<z.ZodNumber>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            match_information: z.ZodOptional<z.ZodUnknown>;
+            address_line_one: z.ZodOptional<z.ZodString>;
+            address_line_two: z.ZodOptional<z.ZodString>;
+            city: z.ZodOptional<z.ZodString>;
+            state: z.ZodOptional<z.ZodString>;
+            zip_code: z.ZodOptional<z.ZodString>;
+            country_iso_2: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+    }, z.core.$strip>;
+    readonly keyAvailability: z.ZodObject<{
+        code: z.ZodNumber;
+        message: z.ZodString;
+        result: z.ZodObject<{
+            available: z.ZodBoolean;
+            context: z.ZodOptional<z.ZodString>;
+            contexts: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        }, z.core.$loose>;
+    }, z.core.$strip>;
+    readonly resolveAddressUsa: z.ZodObject<{
+        code: z.ZodNumber;
+        message: z.ZodString;
+        result: z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            line_1: z.ZodOptional<z.ZodString>;
+            line_2: z.ZodOptional<z.ZodString>;
+            city: z.ZodOptional<z.ZodString>;
+            state: z.ZodOptional<z.ZodString>;
+            state_abbreviation: z.ZodOptional<z.ZodString>;
+            zip_code: z.ZodOptional<z.ZodString>;
+            country_iso_2: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+    }, z.core.$strip>;
+};
+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;AAExB,QAAA,MAAM,uBAAuB;;;;;iBAQpB,CAAC;AAEV,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,gCAAgC;;;;iBAQ3C,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,gCAAgC,CACvC,CAAC;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;iBAQ9C,CAAC;AAEH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,mCAAmC,CAC1C,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;iBAcnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAwB1E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;iBAItC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,0BAA0B,gCAAe,CAAC;AAEvD,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,6BAA6B;;;;;;;;iBAWxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,6BAA6B,CACpC,CAAC;AAEF,eAAO,MAAM,4BAA4B;;iBAOvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,4BAA4B,CACnC,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;iBAgB1C,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,+BAA+B,CACtC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACtC,qBAAqB,EAAE,0BAA0B,CAAC;IAClD,aAAa,EAAE,kBAAkB,CAAC;IAClC,eAAe,EAAE,oBAAoB,CAAC;IACtC,iBAAiB,EAAE,sBAAsB,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACvC,qBAAqB,EAAE,6BAA6B,CAAC;IACrD,aAAa,EAAE,qBAAqB,CAAC;IACrC,eAAe,EAAE,uBAAuB,CAAC;IACzC,iBAAiB,EAAE,yBAAyB,CAAC;CAC7C,CAAC;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;CAKjC,CAAC;AAEX,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKlC,CAAC"}

package/dist/endpoints/verify.d.ts

@@ -0,0 +1,9 @@
+import type { AddresszenEndpoints } from '../index';
+/**
+ * Verify and standardize a US address using USPS CASS.
+ *
+ * API: POST /verify/addresses
+ * Docs: https://docs.addresszen.com/docs/api/address-verify
+ */
+export declare const address: AddresszenEndpoints['verifyAddress'];
+//# 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":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAGpD;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,mBAAmB,CAAC,eAAe,CAkDxD,CAAC"}

package/dist/error-handlers.d.ts

@@ -0,0 +1,36 @@
+export declare const errorHandlers: {
+    RATE_LIMIT_ERROR: {
+        match: (error: Error) => boolean;
+        handler: (error: Error) => Promise<{
+            maxRetries: number;
+            retryStrategy: "exponential_backoff";
+            headersRetryAfterMs: number | undefined;
+        }>;
+    };
+    AUTH_ERROR: {
+        match: (error: Error) => boolean;
+        handler: () => Promise<{
+            maxRetries: number;
+        }>;
+    };
+    NOT_FOUND_ERROR: {
+        match: (error: Error) => boolean;
+        handler: () => Promise<{
+            maxRetries: number;
+        }>;
+    };
+    SERVER_ERROR: {
+        match: (error: Error) => boolean;
+        handler: () => Promise<{
+            maxRetries: number;
+            retryStrategy: "exponential_backoff";
+        }>;
+    };
+    DEFAULT: {
+        match: () => true;
+        handler: () => 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,eAAO,MAAM,aAAa;;uBAET,KAAK;yBAKG,KAAK;;;;;;;uBAOb,KAAK;;;;;;uBAYL,KAAK;;;;;;uBAQL,KAAK;;;;;;;;;;;;CAeS,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,128 @@
+import type { AuthTypes, BindEndpoints, CorsairEndpoint, CorsairErrorHandler, CorsairPlugin, CorsairPluginContext, KeyBuilderContext, PickAuth, PluginPermissionsConfig } from 'corsair/core';
+import type { AddresszenEndpointInputs, AddresszenEndpointOutputs } from './endpoints/types';
+import { AddresszenSchema } from './schema';
+export type AddresszenPluginOptions = {
+    authType?: PickAuth<'api_key'>;
+    key?: string;
+    hooks?: InternalAddresszenPlugin['hooks'];
+    errorHandlers?: CorsairErrorHandler;
+    permissions?: PluginPermissionsConfig<typeof addresszenEndpointsNested>;
+};
+export type AddresszenContext = CorsairPluginContext<typeof AddresszenSchema, AddresszenPluginOptions>;
+export type AddresszenKeyBuilderContext = KeyBuilderContext<AddresszenPluginOptions>;
+export type AddresszenBoundEndpoints = BindEndpoints<typeof addresszenEndpointsNested>;
+type AddresszenEndpoint<K extends keyof AddresszenEndpointOutputs> = CorsairEndpoint<AddresszenContext, AddresszenEndpointInputs[K], AddresszenEndpointOutputs[K]>;
+export type AddresszenEndpoints = {
+    autocompleteAddresses: AddresszenEndpoint<'autocompleteAddresses'>;
+    verifyAddress: AddresszenEndpoint<'verifyAddress'>;
+    keyAvailability: AddresszenEndpoint<'keyAvailability'>;
+    resolveAddressUsa: AddresszenEndpoint<'resolveAddressUsa'>;
+};
+declare const addresszenEndpointsNested: {
+    readonly autocomplete: {
+        readonly addresses: AddresszenEndpoint<"autocompleteAddresses">;
+    };
+    readonly verify: {
+        readonly address: AddresszenEndpoint<"verifyAddress">;
+    };
+    readonly key: {
+        readonly availability: AddresszenEndpoint<"keyAvailability">;
+    };
+    readonly resolve: {
+        readonly addressUsa: AddresszenEndpoint<"resolveAddressUsa">;
+    };
+};
+declare const addresszenWebhooksNested: {};
+export declare const addresszenEndpointSchemas: {
+    readonly 'autocomplete.addresses': {
+        readonly input: import("zod").ZodObject<{
+            query: import("zod").ZodString;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            page: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            code: import("zod").ZodNumber;
+            message: import("zod").ZodString;
+            result: import("zod").ZodObject<{
+                hits: import("zod").ZodArray<import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    suggestion: import("zod").ZodString;
+                    urls: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+                    udprn: import("zod").ZodOptional<import("zod").ZodNumber>;
+                }, import("zod/v4/core").$loose>>;
+            }, import("zod/v4/core").$loose>;
+        }, import("zod/v4/core").$strip>;
+    };
+    readonly 'verify.address': {
+        readonly input: import("zod").ZodObject<{
+            query: import("zod").ZodString;
+            zip_code: import("zod").ZodOptional<import("zod").ZodString>;
+            city: import("zod").ZodOptional<import("zod").ZodString>;
+            state: import("zod").ZodOptional<import("zod").ZodString>;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            code: import("zod").ZodNumber;
+            message: import("zod").ZodString;
+            result: import("zod").ZodObject<{
+                query: import("zod").ZodString;
+                query_city: import("zod").ZodOptional<import("zod").ZodString>;
+                query_state: import("zod").ZodOptional<import("zod").ZodString>;
+                query_zip_code: import("zod").ZodOptional<import("zod").ZodString>;
+                match: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnknown>>;
+                count: import("zod").ZodOptional<import("zod").ZodNumber>;
+                fit: import("zod").ZodOptional<import("zod").ZodNumber>;
+                confidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+                match_information: import("zod").ZodOptional<import("zod").ZodUnknown>;
+                address_line_one: import("zod").ZodOptional<import("zod").ZodString>;
+                address_line_two: import("zod").ZodOptional<import("zod").ZodString>;
+                city: import("zod").ZodOptional<import("zod").ZodString>;
+                state: import("zod").ZodOptional<import("zod").ZodString>;
+                zip_code: import("zod").ZodOptional<import("zod").ZodString>;
+                country_iso_2: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>;
+        }, import("zod/v4/core").$strip>;
+    };
+    readonly 'key.availability': {
+        readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            code: import("zod").ZodNumber;
+            message: import("zod").ZodString;
+            result: import("zod").ZodObject<{
+                available: import("zod").ZodBoolean;
+                context: import("zod").ZodOptional<import("zod").ZodString>;
+                contexts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+            }, import("zod/v4/core").$loose>;
+        }, import("zod/v4/core").$strip>;
+    };
+    readonly 'resolve.addressUsa': {
+        readonly input: import("zod").ZodObject<{
+            addressId: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{
+            code: import("zod").ZodNumber;
+            message: import("zod").ZodString;
+            result: import("zod").ZodObject<{
+                id: import("zod").ZodOptional<import("zod").ZodString>;
+                line_1: import("zod").ZodOptional<import("zod").ZodString>;
+                line_2: import("zod").ZodOptional<import("zod").ZodString>;
+                city: import("zod").ZodOptional<import("zod").ZodString>;
+                state: import("zod").ZodOptional<import("zod").ZodString>;
+                state_abbreviation: import("zod").ZodOptional<import("zod").ZodString>;
+                zip_code: import("zod").ZodOptional<import("zod").ZodString>;
+                country_iso_2: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>;
+        }, import("zod/v4/core").$strip>;
+    };
+};
+declare const defaultAuthType: AuthTypes;
+export declare const addresszenAuthConfig: {
+    readonly api_key: {};
+};
+export type BaseAddresszenPlugin<T extends AddresszenPluginOptions> = CorsairPlugin<'addresszen', typeof AddresszenSchema, typeof addresszenEndpointsNested, typeof addresszenWebhooksNested, T, typeof defaultAuthType>;
+export type InternalAddresszenPlugin = BaseAddresszenPlugin<AddresszenPluginOptions>;
+export type ExternalAddresszenPlugin<T extends AddresszenPluginOptions> = BaseAddresszenPlugin<T>;
+export declare function addresszen<const T extends AddresszenPluginOptions>(incomingOptions?: AddresszenPluginOptions & T): ExternalAddresszenPlugin<T>;
+export type { AddressSuggestion, AddresszenEndpointInputs, AddresszenEndpointOutputs, AutocompleteAddressesInput, AutocompleteAddressesResponse, KeyAvailabilityInput, KeyAvailabilityResponse, ResolveAddressUsaInput, ResolveAddressUsaResponse, VerifyAddressInput, VerifyAddressResponse, } from './endpoints/types';
+export { AddresszenEndpointInputSchemas, AddresszenEndpointOutputSchemas, AutocompleteAddressesInputSchema, AutocompleteAddressesResponseSchema, KeyAvailabilityInputSchema, KeyAvailabilityResponseSchema, ResolveAddressUsaInputSchema, ResolveAddressUsaResponseSchema, VerifyAddressInputSchema, VerifyAddressResponseSchema, } 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,SAAS,EACT,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,QAAQ,EAER,uBAAuB,EAGvB,MAAM,cAAc,CAAC;AAGtB,OAAO,KAAK,EACX,wBAAwB,EACxB,yBAAyB,EACzB,MAAM,mBAAmB,CAAC;AAM3B,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE5C,MAAM,MAAM,uBAAuB,GAAG;IACrC,QAAQ,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,wBAAwB,CAAC,OAAO,CAAC,CAAC;IAC1C,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC,WAAW,CAAC,EAAE,uBAAuB,CAAC,OAAO,yBAAyB,CAAC,CAAC;CACxE,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,oBAAoB,CACnD,OAAO,gBAAgB,EACvB,uBAAuB,CACvB,CAAC;AAEF,MAAM,MAAM,2BAA2B,GACtC,iBAAiB,CAAC,uBAAuB,CAAC,CAAC;AAE5C,MAAM,MAAM,wBAAwB,GAAG,aAAa,CACnD,OAAO,yBAAyB,CAChC,CAAC;AAEF,KAAK,kBAAkB,CAAC,CAAC,SAAS,MAAM,yBAAyB,IAChE,eAAe,CACd,iBAAiB,EACjB,wBAAwB,CAAC,CAAC,CAAC,EAC3B,yBAAyB,CAAC,CAAC,CAAC,CAC5B,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG;IACjC,qBAAqB,EAAE,kBAAkB,CAAC,uBAAuB,CAAC,CAAC;IACnE,aAAa,EAAE,kBAAkB,CAAC,eAAe,CAAC,CAAC;IACnD,eAAe,EAAE,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;IACvD,iBAAiB,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;CAC3D,CAAC;AAEF,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;CAarB,CAAC;AAEX,QAAA,MAAM,wBAAwB,IAAc,CAAC;AAE7C,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBrC,CAAC;AAEF,QAAA,MAAM,eAAe,EAAE,SAA8B,CAAC;AA2BtD,eAAO,MAAM,oBAAoB;;CAEI,CAAC;AAEtC,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,uBAAuB,IACjE,aAAa,CACZ,YAAY,EACZ,OAAO,gBAAgB,EACvB,OAAO,yBAAyB,EAChC,OAAO,wBAAwB,EAC/B,CAAC,EACD,OAAO,eAAe,CACtB,CAAC;AAEH,MAAM,MAAM,wBAAwB,GACnC,oBAAoB,CAAC,uBAAuB,CAAC,CAAC;AAE/C,MAAM,MAAM,wBAAwB,CAAC,CAAC,SAAS,uBAAuB,IACrE,oBAAoB,CAAC,CAAC,CAAC,CAAC;AAEzB,wBAAgB,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,uBAAuB,EACjE,eAAe,GAAE,uBAAuB,GAAG,CACzC,GACA,wBAAwB,CAAC,CAAC,CAAC,CAqC7B;AAED,YAAY,EACX,iBAAiB,EACjB,wBAAwB,EACxB,yBAAyB,EACzB,0BAA0B,EAC1B,6BAA6B,EAC7B,oBAAoB,EACpB,uBAAuB,EACvB,sBAAsB,EACtB,yBAAyB,EACzB,kBAAkB,EAClB,qBAAqB,GACrB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACN,8BAA8B,EAC9B,+BAA+B,EAC/B,gCAAgC,EAChC,mCAAmC,EACnC,0BAA0B,EAC1B,6BAA6B,EAC7B,4BAA4B,EAC5B,+BAA+B,EAC/B,wBAAwB,EACxB,2BAA2B,GAC3B,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+import{AuthMissingError as j}from"corsair/core";import{logEventFromContext as F}from"corsair/core";import{ApiError as m,request as D}from"corsair/http";var c=class extends Error{constructor(o,n,d){super(o,d);this.code=n;this.name="AddresszenAPIError",d?.cause instanceof m&&(this.status=d.cause.status,this.statusText=d.cause.statusText,this.body=d.cause.body,this.retryAfter=d.cause.retryAfter)}status;statusText;body;retryAfter},L="https://api.addresszen.com/v1";async function i(t,s,o={}){let{method:n="GET",body:d,query:u={},auth:B=!0}=o,A=n==="POST"||n==="PUT"||n==="PATCH",N={BASE:L,VERSION:"1.0.0",WITH_CREDENTIALS:!1,CREDENTIALS:"omit",TOKEN:void 0,HEADERS:{...B?{Authorization:`api_key="${s}"`}:{},...A?{"Content-Type":"application/json"}:{}}},H={method:n,url:t,body:A?d:void 0,mediaType:A?"application/json; charset=utf-8":void 0,query:u};try{return await D(N,H)}catch(a){throw a instanceof m?new c(a.message,a.status,{cause:a}):a instanceof Error?new c(a.message,void 0,{cause:a}):new c("Unknown error")}}var f=async(t,s)=>{let o=await i("autocomplete/addresses",t.key,{method:"GET",query:{q:s.query,limit:s.limit,page:s.page}});if(t.db.autocompleteResults)try{let{result:n,...d}=o;await t.db.autocompleteResults.upsertByEntityId(s.query,{...d,query:s.query,hits:n.hits,updatedAt:new Date})}catch(n){console.warn("[addresszen] Failed to save autocomplete results to database:",n)}return await F(t,"addresszen.autocomplete.addresses",{query:s.query,hitCount:o.result.hits.length},"completed"),o};import{logEventFromContext as M}from"corsair/core";var g=async(t,s)=>{let o=await i(`keys/${encodeURIComponent(t.key)}`,t.key,{method:"GET",auth:!1});if(t.db.keyAvailability)try{let n=await t.$getAccountId();await t.db.keyAvailability.upsertByEntityId(n,{available:o.result.available,context:o.result.context??null,code:o.code,message:o.message,updatedAt:new Date})}catch(n){console.warn("[addresszen] Failed to save key availability to database:",n)}return await M(t,"addresszen.key.availability",{available:o.result.available},"completed"),o};import{logEventFromContext as G}from"corsair/core";var z=async(t,s)=>{let o=await i(`autocomplete/addresses/${encodeURIComponent(s.addressId)}/usa`,t.key,{method:"GET"});if(t.db.resolvedAddresses)try{let{result:n,...d}=o;await t.db.resolvedAddresses.upsertByEntityId(s.addressId,{...d,addressId:s.addressId,address:n,updatedAt:new Date})}catch(n){console.warn("[addresszen] Failed to save resolved address to database:",n)}return await G(t,"addresszen.resolve.addressUsa",{addressId:s.addressId},"completed"),o};import{logEventFromContext as W}from"corsair/core";var b=async(t,s)=>{let{context:o,...n}=s,d=await i("verify/addresses",t.key,{method:"POST",query:o?{context:o}:void 0,body:n});if(t.db.verifiedAddresses)try{let u=JSON.stringify([s.query,s.city??null,s.state??null,s.zip_code??null,s.context??null]);await t.db.verifiedAddresses.upsertByEntityId(u,{...d,query:s.query,city:s.city??null,state:s.state??null,zipCode:s.zip_code??null,context:s.context??null,updatedAt:new Date})}catch(u){console.warn("[addresszen] Failed to save verified address to database:",u)}return await W(t,"addresszen.verify.address",{query:s.query},"completed"),d};import{z as e}from"zod";var $=e.object({id:e.string(),suggestion:e.string(),urls:e.record(e.string(),e.unknown()).nullable().optional(),udprn:e.number().optional()}).loose(),h=e.object({query:e.string().min(1).max(150).describe("Partial address string to autocomplete"),limit:e.number().int().positive().optional(),page:e.number().int().nonnegative().optional()}),v=e.object({code:e.number(),message:e.string(),result:e.object({hits:e.array($)}).loose()}),E=e.object({query:e.string().min(1).describe("Address to verify. Use a full free-form address, or only the first line when city/state or zip_code are provided separately."),zip_code:e.string().optional(),city:e.string().optional(),state:e.string().optional(),context:e.string().optional().describe("Optional metadata tag stored with the lookup")}),J=e.object({query:e.string(),query_city:e.string().optional(),query_state:e.string().optional(),query_zip_code:e.string().optional(),match:e.unknown().nullable().optional(),count:e.number().optional(),fit:e.number().optional(),confidence:e.number().optional(),match_information:e.unknown().optional(),address_line_one:e.string().optional(),address_line_two:e.string().optional(),city:e.string().optional(),state:e.string().optional(),zip_code:e.string().optional(),country_iso_2:e.string().optional()}).loose(),R=e.object({code:e.number(),message:e.string(),result:J}),x=e.object({}),k=e.object({code:e.number(),message:e.string(),result:e.object({available:e.boolean(),context:e.string().optional(),contexts:e.array(e.record(e.string(),e.unknown())).optional()}).loose()}),S=e.object({addressId:e.string().min(1).describe("Address suggestion ID from autocomplete (e.g. usps_X130125796|1600||1933)")}),I=e.object({code:e.number(),message:e.string(),result:e.object({id:e.string().optional(),line_1:e.string().optional(),line_2:e.string().optional(),city:e.string().optional(),state:e.string().optional(),state_abbreviation:e.string().optional(),zip_code:e.string().optional(),country_iso_2:e.string().optional()}).loose()}),p={autocompleteAddresses:h,verifyAddress:E,keyAvailability:x,resolveAddressUsa:S},l={autocompleteAddresses:v,verifyAddress:R,keyAvailability:k,resolveAddressUsa:I};var w={addresses:f},P={address:b},T={availability:g},C={addressUsa:z};function y(t){return t.status}function X(t){return t.retryAfter}var _={RATE_LIMIT_ERROR:{match:t=>{if(y(t)===429)return!0;let s=t.message.toLowerCase();return s.includes("429")||s.includes("rate limit")},handler:async t=>({maxRetries:3,retryStrategy:"exponential_backoff",headersRetryAfterMs:X(t)})},AUTH_ERROR:{match:t=>{if(y(t)===401)return!0;let s=t.message.toLowerCase();return s.includes("invalid key")||s.includes("unauthorized")||s.includes("401")},handler:async()=>({maxRetries:0})},NOT_FOUND_ERROR:{match:t=>{if(y(t)===404)return!0;let s=t.message.toLowerCase();return s.includes("404")||s.includes("not found")},handler:async()=>({maxRetries:0})},SERVER_ERROR:{match:t=>{let s=y(t);if(s!==void 0&&s>=500)return!0;let o=t.message.toLowerCase();return o.includes("503")||o.includes("server error")},handler:async()=>({maxRetries:2,retryStrategy:"exponential_backoff"})},DEFAULT:{match:()=>!0,handler:async()=>({maxRetries:0})}};import{z as r}from"zod";var O=r.object({query:r.string(),hits:r.array(r.record(r.string(),r.unknown())),code:r.number().optional(),message:r.string().optional(),updatedAt:r.coerce.date().nullable().optional()}),U=r.object({query:r.string(),city:r.string().nullable().optional(),state:r.string().nullable().optional(),zipCode:r.string().nullable().optional(),context:r.string().nullable().optional(),result:r.record(r.string(),r.unknown()),code:r.number().optional(),message:r.string().optional(),updatedAt:r.coerce.date().nullable().optional()}),q=r.object({available:r.boolean(),context:r.string().nullable().optional(),code:r.number().optional(),message:r.string().optional(),updatedAt:r.coerce.date().nullable().optional()}),K=r.object({addressId:r.string(),address:r.record(r.string(),r.unknown()),code:r.number().optional(),message:r.string().optional(),updatedAt:r.coerce.date().nullable().optional()});var V={version:"1.0.0",entities:{autocompleteResults:O,verifiedAddresses:U,keyAvailability:q,resolvedAddresses:K}};var Z={autocomplete:{addresses:w.addresses},verify:{address:P.address},key:{availability:T.availability},resolve:{addressUsa:C.addressUsa}},Q={},Y={"autocomplete.addresses":{input:p.autocompleteAddresses,output:l.autocompleteAddresses},"verify.address":{input:p.verifyAddress,output:l.verifyAddress},"key.availability":{input:p.keyAvailability,output:l.keyAvailability},"resolve.addressUsa":{input:p.resolveAddressUsa,output:l.resolveAddressUsa}},ee="api_key",se={"autocomplete.addresses":{riskLevel:"read",description:"Get address autocomplete suggestions for a partial address query"},"verify.address":{riskLevel:"read",description:"Verify and standardize a US address using USPS CASS validation"},"key.availability":{riskLevel:"read",description:"Get public information on an API key, including whether it is currently usable"},"resolve.addressUsa":{riskLevel:"read",description:"Resolve an address autocompletion by its address ID and return the full address in US format"}},te={api_key:{}};function qe(t={}){let s={...t,authType:t.authType??ee};return{id:"addresszen",authConfig:te,schema:V,options:s,hooks:s.hooks,webhookHooks:void 0,endpoints:Z,webhooks:Q,endpointMeta:se,endpointSchemas:Y,pluginWebhookMatcher:void 0,errorHandlers:{..._,...s.errorHandlers},keyBuilder:async(o,n)=>{if(n==="endpoint"&&s.key)return s.key;if(n==="endpoint"&&o.authType==="api_key"){let d=await o.keys.get_api_key();if(!d)throw new j("addresszen","api_key");return d}throw new j("addresszen","api_key")}}}export{p as AddresszenEndpointInputSchemas,l as AddresszenEndpointOutputSchemas,h as AutocompleteAddressesInputSchema,v as AutocompleteAddressesResponseSchema,x as KeyAvailabilityInputSchema,k as KeyAvailabilityResponseSchema,S as ResolveAddressUsaInputSchema,I as ResolveAddressUsaResponseSchema,E as VerifyAddressInputSchema,R as VerifyAddressResponseSchema,qe as addresszen,te as addresszenAuthConfig,Y as addresszenEndpointSchemas};

package/dist/schema/database.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const AddresszenAutocompleteResult: z.ZodObject<{
+    query: z.ZodString;
+    hits: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    code: z.ZodOptional<z.ZodNumber>;
+    message: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+}, z.core.$strip>;
+export declare const AddresszenVerifiedAddress: z.ZodObject<{
+    query: z.ZodString;
+    city: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    state: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    zipCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    context: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    code: z.ZodOptional<z.ZodNumber>;
+    message: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+}, z.core.$strip>;
+export declare const AddresszenKeyAvailability: z.ZodObject<{
+    available: z.ZodBoolean;
+    context: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    code: z.ZodOptional<z.ZodNumber>;
+    message: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+}, z.core.$strip>;
+export declare const AddresszenResolvedAddress: z.ZodObject<{
+    addressId: z.ZodString;
+    address: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    code: z.ZodOptional<z.ZodNumber>;
+    message: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+}, z.core.$strip>;
+export type AddresszenAutocompleteResult = z.infer<typeof AddresszenAutocompleteResult>;
+export type AddresszenVerifiedAddress = z.infer<typeof AddresszenVerifiedAddress>;
+export type AddresszenKeyAvailability = z.infer<typeof AddresszenKeyAvailability>;
+export type AddresszenResolvedAddress = z.infer<typeof AddresszenResolvedAddress>;
+//# 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,4BAA4B;;;;;;iBAOvC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;iBAWpC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;iBAMpC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;iBAOpC,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,4BAA4B,CACnC,CAAC;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,yBAAyB,CAChC,CAAC;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,yBAAyB,CAChC,CAAC;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,yBAAyB,CAChC,CAAC"}

package/dist/schema/index.d.ts

@@ -0,0 +1,38 @@
+export declare const AddresszenSchema: {
+    readonly version: "1.0.0";
+    readonly entities: {
+        readonly autocompleteResults: import("zod").ZodObject<{
+            query: import("zod").ZodString;
+            hits: import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            code: import("zod").ZodOptional<import("zod").ZodNumber>;
+            message: import("zod").ZodOptional<import("zod").ZodString>;
+            updatedAt: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodCoercedDate<unknown>>>;
+        }, import("zod/v4/core").$strip>;
+        readonly verifiedAddresses: import("zod").ZodObject<{
+            query: import("zod").ZodString;
+            city: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            state: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            zipCode: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            context: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            result: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            code: import("zod").ZodOptional<import("zod").ZodNumber>;
+            message: import("zod").ZodOptional<import("zod").ZodString>;
+            updatedAt: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodCoercedDate<unknown>>>;
+        }, import("zod/v4/core").$strip>;
+        readonly keyAvailability: import("zod").ZodObject<{
+            available: import("zod").ZodBoolean;
+            context: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+            code: import("zod").ZodOptional<import("zod").ZodNumber>;
+            message: import("zod").ZodOptional<import("zod").ZodString>;
+            updatedAt: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodCoercedDate<unknown>>>;
+        }, import("zod/v4/core").$strip>;
+        readonly resolvedAddresses: import("zod").ZodObject<{
+            addressId: import("zod").ZodString;
+            address: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            code: import("zod").ZodOptional<import("zod").ZodNumber>;
+            message: import("zod").ZodOptional<import("zod").ZodString>;
+            updatedAt: 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":"AAOA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQnB,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

@@ -0,0 +1,45 @@
+{
+  "name": "@corsair-dev/addresszen",
+  "version": "0.1.0",
+  "description": "Addresszen 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",
+    "dotenv": "^17.2.3",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.9",
+    "tsup": "^8.0.1",
+    "typescript": "^5.9.3",
+    "zod": "^4.1.13",
+    "corsair": "0.1.111"
+  },
+  "keywords": [
+    "corsair",
+    "addresszen",
+    "plugin"
+  ],
+  "author": "",
+  "license": "Apache-2.0",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc --build --force && tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "jest"
+  }
+}