contiguity 0.0.1

package/dist/services/domains/delete.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const DomainsDeleteRequest: z.ZodObject<{
+    domain: z.ZodString;
+}, z.core.$strip>;
+export declare const DomainsDeleteResponse: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare const DomainsDeleteResponseBuilder: import("@/types/base").BaseResponseBuilder<z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+}, z.core.$strip>>;
+export type DomainsDeleteParams = z.infer<typeof DomainsDeleteRequest>;
+export type DomainsDeleteResponse = z.infer<typeof DomainsDeleteResponse>;
+/**
+ * Deletes a domain from your account
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.domains.delete({
+ *   domain: "example.com"
+ * });
+ *
+ * if (response.success) {
+ *   console.log(`Domain deleted successfully: ${response.message}`);
+ * } else {
+ *   console.log(`Failed to delete domain: ${response.message}`);
+ * }
+ * ```
+ */
+export declare function _domainsDelete(this: any, params: DomainsDeleteParams): Promise<any>;
+//# sourceMappingURL=delete.d.ts.map

package/dist/services/domains/delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/services/domains/delete.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,oBAAoB;;iBAG/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;iBAKhC,CAAC;AAGH,eAAO,MAAM,4BAA4B;;;kBAAwC,CAAC;AAElF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACvE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,GAAG,CAAC,CAazF"}

package/dist/services/domains/delete.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { createResponse } from "@/types/base";
+export const DomainsDeleteRequest = z.object({
+    /** Domain name to delete */
+    domain: z.string().min(1, "Domain cannot be empty"),
+});
+export const DomainsDeleteResponse = z.object({
+    /** Whether the deletion was successful */
+    success: z.boolean(),
+    /** Success message */
+    message: z.string(),
+});
+// Using the new base response builder
+export const DomainsDeleteResponseBuilder = createResponse(DomainsDeleteResponse);
+/**
+ * Deletes a domain from your account
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.domains.delete({
+ *   domain: "example.com"
+ * });
+ *
+ * if (response.success) {
+ *   console.log(`Domain deleted successfully: ${response.message}`);
+ * } else {
+ *   console.log(`Failed to delete domain: ${response.message}`);
+ * }
+ * ```
+ */
+export async function _domainsDelete(params) {
+    const validatedParams = DomainsDeleteRequest.parse(params);
+    const response = await this.request(`/domains/${encodeURIComponent(validatedParams.domain)}`, {
+        method: "DELETE",
+    });
+    return this.parse({
+        response,
+        schemas: {
+            sdk: DomainsDeleteResponse,
+            raw: DomainsDeleteResponseBuilder.raw
+        }
+    });
+}

package/dist/services/domains/get.d.ts

@@ -0,0 +1,128 @@
+import { z } from "zod";
+export declare const DNSRecord: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+    purpose: z.ZodString;
+}, z.core.$strip>;
+export declare const DNSRecords: z.ZodObject<{
+    MX: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+        purpose: z.ZodString;
+    }, z.core.$strip>>>;
+    TXT: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+        purpose: z.ZodString;
+    }, z.core.$strip>>>;
+    CNAME: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+        purpose: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const DomainVerifications: z.ZodObject<{
+    dkim: z.ZodString;
+    mail_from: z.ZodString;
+    domain: z.ZodString;
+}, z.core.$strip>;
+export declare const DomainsGetRequest: z.ZodObject<{
+    domain: z.ZodString;
+}, z.core.$strip>;
+export declare const DomainsGetResponse: z.ZodObject<{
+    domain: z.ZodString;
+    status: z.ZodString;
+    id: z.ZodString;
+    created_at: z.ZodNumber;
+    records: z.ZodArray<z.ZodObject<{
+        MX: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            purpose: z.ZodString;
+        }, z.core.$strip>>>;
+        TXT: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            purpose: z.ZodString;
+        }, z.core.$strip>>>;
+        CNAME: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            purpose: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    region: z.ZodString;
+    sending_allowed: z.ZodBoolean;
+    verifications: z.ZodObject<{
+        dkim: z.ZodString;
+        mail_from: z.ZodString;
+        domain: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const DomainsGetResponseBuilder: import("@/types/base").BaseResponseBuilder<z.ZodObject<{
+    domain: z.ZodString;
+    status: z.ZodString;
+    id: z.ZodString;
+    created_at: z.ZodNumber;
+    records: z.ZodArray<z.ZodObject<{
+        MX: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            purpose: z.ZodString;
+        }, z.core.$strip>>>;
+        TXT: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            purpose: z.ZodString;
+        }, z.core.$strip>>>;
+        CNAME: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            purpose: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    region: z.ZodString;
+    sending_allowed: z.ZodBoolean;
+    verifications: z.ZodObject<{
+        dkim: z.ZodString;
+        mail_from: z.ZodString;
+        domain: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>>;
+export type DomainsGetParams = z.infer<typeof DomainsGetRequest>;
+export type DomainsGetResponse = z.infer<typeof DomainsGetResponse>;
+export type DNSRecord = z.infer<typeof DNSRecord>;
+export type DomainVerifications = z.infer<typeof DomainVerifications>;
+/**
+ * Gets domain verification status and DNS instructions
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.domains.get({
+ *   domain: "example.com"
+ * });
+ *
+ * console.log(`Domain: ${response.domain}`);
+ * console.log(`Status: ${response.status}`);
+ * console.log(`Sending allowed: ${response.sending_allowed}`);
+ * console.log(`DKIM status: ${response.verifications.dkim}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Check DNS records
+ * const response = await contiguity.domains.get({
+ *   domain: "example.com"
+ * });
+ *
+ * response.records.forEach(recordGroup => {
+ *   if (recordGroup.TXT) {
+ *     recordGroup.TXT.forEach(record => {
+ *       console.log(`TXT Record: ${record.name} -> ${record.value} (${record.purpose})`);
+ *     });
+ *   }
+ * });
+ * ```
+ */
+export declare function _domainsGet(this: any, params: DomainsGetParams): Promise<any>;
+//# sourceMappingURL=get.d.ts.map

package/dist/services/domains/get.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../../src/services/domains/get.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,SAAS;;;;iBAOpB,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;iBAOrB,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;iBAO9B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;iBAG5B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiB7B,CAAC;AAGH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAqC,CAAC;AAE5E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AACjE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACpE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAClD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,GAAG,CAAC,CAanF"}

package/dist/services/domains/get.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { createResponse } from "@/types/base";
+// DNS Record schemas based on OpenAPI spec
+export const DNSRecord = z.object({
+    /** Record name */
+    name: z.string(),
+    /** Record value */
+    value: z.string(),
+    /** Record purpose */
+    purpose: z.string(),
+});
+export const DNSRecords = z.object({
+    /** MX records */
+    MX: z.array(DNSRecord).optional(),
+    /** TXT records */
+    TXT: z.array(DNSRecord).optional(),
+    /** CNAME records */
+    CNAME: z.array(DNSRecord).optional(),
+});
+export const DomainVerifications = z.object({
+    /** DKIM configuration status */
+    dkim: z.string(),
+    /** Mail-from domain verification status */
+    mail_from: z.string(),
+    /** Domain verification status */
+    domain: z.string(),
+});
+export const DomainsGetRequest = z.object({
+    /** Domain name to get information about */
+    domain: z.string().min(1, "Domain cannot be empty"),
+});
+export const DomainsGetResponse = z.object({
+    /** The domain name */
+    domain: z.string(),
+    /** Domain verification status */
+    status: z.string(),
+    /** Domain ID */
+    id: z.string(),
+    /** Domain creation timestamp */
+    created_at: z.number(),
+    /** DNS records grouped by type */
+    records: z.array(DNSRecords),
+    /** AWS region */
+    region: z.string(),
+    /** Whether sending is allowed using this domain */
+    sending_allowed: z.boolean(),
+    /** Verification status details */
+    verifications: DomainVerifications,
+});
+// Using the new base response builder - this replaces the manual Flattened/Raw definitions
+export const DomainsGetResponseBuilder = createResponse(DomainsGetResponse);
+/**
+ * Gets domain verification status and DNS instructions
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.domains.get({
+ *   domain: "example.com"
+ * });
+ *
+ * console.log(`Domain: ${response.domain}`);
+ * console.log(`Status: ${response.status}`);
+ * console.log(`Sending allowed: ${response.sending_allowed}`);
+ * console.log(`DKIM status: ${response.verifications.dkim}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Check DNS records
+ * const response = await contiguity.domains.get({
+ *   domain: "example.com"
+ * });
+ *
+ * response.records.forEach(recordGroup => {
+ *   if (recordGroup.TXT) {
+ *     recordGroup.TXT.forEach(record => {
+ *       console.log(`TXT Record: ${record.name} -> ${record.value} (${record.purpose})`);
+ *     });
+ *   }
+ * });
+ * ```
+ */
+export async function _domainsGet(params) {
+    const validatedParams = DomainsGetRequest.parse(params);
+    const response = await this.request(`/domains/${encodeURIComponent(validatedParams.domain)}`, {
+        method: "GET",
+    });
+    return this.parse({
+        response,
+        schemas: {
+            sdk: DomainsGetResponse,
+            raw: DomainsGetResponseBuilder.raw
+        }
+    });
+}

package/dist/services/domains/index.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { ContiguityClient } from "@/client/fetch";
+import type { WithMetadata } from "@/types/metadata";
+import { DomainsListResponse } from "./list";
+import { type DomainsGetParams, DomainsGetResponse } from "./get";
+import { type DomainsRegisterParams, DomainsRegisterResponse } from "./register";
+import { type DomainsDeleteParams, DomainsDeleteResponse } from "./delete";
+export type DomainsListResponseType = z.infer<typeof DomainsListResponse>;
+export type DomainsGetResponseType = z.infer<typeof DomainsGetResponse>;
+export type DomainsRegisterResponseType = z.infer<typeof DomainsRegisterResponse>;
+export type DomainsDeleteResponseType = z.infer<typeof DomainsDeleteResponse>;
+/**
+ * Domains service for managing email domains
+ */
+export declare class DomainsService extends ContiguityClient {
+    constructor(token: string);
+    /**
+     * List all domains owned by the user
+     */
+    list(): Promise<WithMetadata<DomainsListResponseType>>;
+    /**
+     * Get domain verification status and DNS instructions
+     */
+    get(params: DomainsGetParams): Promise<WithMetadata<DomainsGetResponseType>>;
+    /**
+     * Register a domain for email sending
+     */
+    register(params: DomainsRegisterParams): Promise<WithMetadata<DomainsRegisterResponseType>>;
+    /**
+     * Delete a domain from your account
+     */
+    delete(params: DomainsDeleteParams): Promise<WithMetadata<DomainsDeleteResponseType>>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/services/domains/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/domains/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAgB,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAC3D,OAAO,EAAe,KAAK,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAC/E,OAAO,EAAoB,KAAK,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AACnG,OAAO,EAAkB,KAAK,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAE3F,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAC1E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACxE,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAClF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE9E;;GAEG;AACH,qBAAa,cAAe,SAAQ,gBAAgB;gBACpC,KAAK,EAAE,MAAM;IAIzB;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,YAAY,CAAC,uBAAuB,CAAC,CAAC;IAI5D;;OAEG;IACG,GAAG,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,sBAAsB,CAAC,CAAC;IAIlF;;OAEG;IACG,QAAQ,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,YAAY,CAAC,2BAA2B,CAAC,CAAC;IAIjG;;OAEG;IACG,MAAM,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC,yBAAyB,CAAC,CAAC;CAG9F"}

package/dist/services/domains/index.js

@@ -0,0 +1,37 @@
+import { ContiguityClient } from "@/client/fetch";
+import { _domainsList } from "./list";
+import { _domainsGet } from "./get";
+import { _domainsRegister } from "./register";
+import { _domainsDelete } from "./delete";
+/**
+ * Domains service for managing email domains
+ */
+export class DomainsService extends ContiguityClient {
+    constructor(token) {
+        super(token);
+    }
+    /**
+     * List all domains owned by the user
+     */
+    async list() {
+        return _domainsList.call(this);
+    }
+    /**
+     * Get domain verification status and DNS instructions
+     */
+    async get(params) {
+        return _domainsGet.call(this, params);
+    }
+    /**
+     * Register a domain for email sending
+     */
+    async register(params) {
+        return _domainsRegister.call(this, params);
+    }
+    /**
+     * Delete a domain from your account
+     */
+    async delete(params) {
+        return _domainsDelete.call(this, params);
+    }
+}

package/dist/services/domains/list.d.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+export declare const DomainInfo: z.ZodObject<{
+    domain: z.ZodString;
+    status: z.ZodString;
+    created_at: z.ZodNumber;
+    id: z.ZodString;
+    region: z.ZodString;
+    sending_allowed: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const DomainsListResponse: z.ZodObject<{
+    domains: z.ZodArray<z.ZodObject<{
+        domain: z.ZodString;
+        status: z.ZodString;
+        created_at: z.ZodNumber;
+        id: z.ZodString;
+        region: z.ZodString;
+        sending_allowed: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const DomainsListResponseFlattened: z.ZodObject<{
+    metadata: z.ZodObject<{
+        id: z.ZodString;
+        timestamp: z.ZodNumber;
+        api_version: z.ZodString;
+        object: z.ZodString;
+    }, z.core.$strip>;
+    domains: z.ZodArray<z.ZodObject<{
+        domain: z.ZodString;
+        status: z.ZodString;
+        created_at: z.ZodNumber;
+        id: z.ZodString;
+        region: z.ZodString;
+        sending_allowed: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const DomainsListResponseRaw: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodNumber;
+    api_version: z.ZodString;
+    object: z.ZodString;
+    data: z.ZodObject<{
+        domains: z.ZodArray<z.ZodObject<{
+            domain: z.ZodString;
+            status: z.ZodString;
+            created_at: z.ZodNumber;
+            id: z.ZodString;
+            region: z.ZodString;
+            sending_allowed: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type DomainsListResponse = z.infer<typeof DomainsListResponse>;
+export type DomainInfo = z.infer<typeof DomainInfo>;
+/**
+ * Lists all domains owned by the user
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.domains.list();
+ *
+ * console.log(`You have ${response.domains.length} domains:`);
+ * response.domains.forEach(domain => {
+ *   console.log(`- ${domain.domain}: ${domain.status} (Region: ${domain.region})`);
+ * });
+ * ```
+ */
+export declare function _domainsList(this: any): Promise<any>;
+//# sourceMappingURL=list.d.ts.map

package/dist/services/domains/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/services/domains/list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,UAAU;;;;;;;iBAarB,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;iBAG9B,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;iBAEvC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;iBAEjC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACtE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD;;;;;;;;;;;;GAYG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAY1D"}

package/dist/services/domains/list.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { ContiguityResponse, ContiguityRawResponse } from "@/types/response";
+// Domain object schema based on OpenAPI spec
+export const DomainInfo = z.object({
+    /** The domain name */
+    domain: z.string(),
+    /** Domain verification status */
+    status: z.string(),
+    /** Domain creation timestamp */
+    created_at: z.number(),
+    /** Domain ID */
+    id: z.string(),
+    /** AWS region */
+    region: z.string(),
+    /** Whether sending is allowed */
+    sending_allowed: z.boolean(),
+});
+export const DomainsListResponse = z.object({
+    /** List of user's domains */
+    domains: z.array(DomainInfo),
+});
+export const DomainsListResponseFlattened = ContiguityResponse.extend({
+    domains: z.array(DomainInfo),
+});
+export const DomainsListResponseRaw = ContiguityRawResponse.extend({
+    data: DomainsListResponse,
+});
+/**
+ * Lists all domains owned by the user
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.domains.list();
+ *
+ * console.log(`You have ${response.domains.length} domains:`);
+ * response.domains.forEach(domain => {
+ *   console.log(`- ${domain.domain}: ${domain.status} (Region: ${domain.region})`);
+ * });
+ * ```
+ */
+export async function _domainsList() {
+    const response = await this.request("/domains/", {
+        method: "GET",
+    });
+    return this.parse({
+        response,
+        schemas: {
+            sdk: DomainsListResponse,
+            raw: DomainsListResponseRaw
+        }
+    });
+}

package/dist/services/domains/register.d.ts

@@ -0,0 +1,89 @@
+import { z } from "zod";
+export declare const DomainsRegisterRequest: z.ZodObject<{
+    domain: z.ZodString;
+    region: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    custom_return_path: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+}, z.core.$strip>;
+export declare const DomainsRegisterResponse: z.ZodObject<{
+    records: z.ZodArray<z.ZodObject<{
+        MX: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            purpose: z.ZodString;
+        }, z.core.$strip>>>;
+        TXT: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            purpose: z.ZodString;
+        }, z.core.$strip>>>;
+        CNAME: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            purpose: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    status: z.ZodString;
+    region: z.ZodString;
+    created_at: z.ZodNumber;
+}, z.core.$strip>;
+export declare const DomainsRegisterResponseBuilder: import("@/types/base").BaseResponseBuilder<z.ZodObject<{
+    records: z.ZodArray<z.ZodObject<{
+        MX: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            purpose: z.ZodString;
+        }, z.core.$strip>>>;
+        TXT: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            purpose: z.ZodString;
+        }, z.core.$strip>>>;
+        CNAME: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            purpose: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    status: z.ZodString;
+    region: z.ZodString;
+    created_at: z.ZodNumber;
+}, z.core.$strip>>;
+export type DomainsRegisterParams = z.infer<typeof DomainsRegisterRequest>;
+export type DomainsRegisterResponse = z.infer<typeof DomainsRegisterResponse>;
+/**
+ * Registers a domain for email sending
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.domains.register({
+ *   domain: "example.com"
+ * });
+ *
+ * console.log(`Domain registered with status: ${response.status}`);
+ * console.log(`Region: ${response.region}`);
+ *
+ * // Display DNS records to configure
+ * response.records.forEach(recordGroup => {
+ *   if (recordGroup.TXT) {
+ *     console.log("TXT Records to add:");
+ *     recordGroup.TXT.forEach(record => {
+ *       console.log(`  ${record.name}: ${record.value} (${record.purpose})`);
+ *     });
+ *   }
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Register domain with custom settings
+ * const response = await contiguity.domains.register({
+ *   domain: "example.com",
+ *   region: "us-east-1",
+ *   custom_return_path: "mail"
+ * });
+ *
+ * console.log(`Created at: ${new Date(response.created_at).toISOString()}`);
+ * ```
+ */
+export declare function _domainsRegister(this: any, params: DomainsRegisterParams): Promise<any>;
+//# sourceMappingURL=register.d.ts.map

package/dist/services/domains/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../src/services/domains/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,sBAAsB;;;;iBAOjC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;iBASlC,CAAC;AAGH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;kBAA0C,CAAC;AAEtF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAC3E,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,GAAG,CAAC,CAgB7F"}

package/dist/services/domains/register.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { createResponse } from "@/types/base";
+import { DNSRecords } from "./get";
+export const DomainsRegisterRequest = z.object({
+    /** Domain name to register */
+    domain: z.string().min(1, "Domain cannot be empty"),
+    /** AWS region */
+    region: z.string().default("us-east-1").optional(),
+    /** Custom return path subdomain */
+    custom_return_path: z.string().default("contiguity").optional(),
+});
+export const DomainsRegisterResponse = z.object({
+    /** DNS records grouped by type */
+    records: z.array(DNSRecords),
+    /** Domain verification status */
+    status: z.string(),
+    /** AWS region (us-east-1 is the default and only currently supported region) */
+    region: z.string(),
+    /** Domain creation timestamp */
+    created_at: z.number(),
+});
+// Using the new base response builder
+export const DomainsRegisterResponseBuilder = createResponse(DomainsRegisterResponse);
+/**
+ * Registers a domain for email sending
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.domains.register({
+ *   domain: "example.com"
+ * });
+ *
+ * console.log(`Domain registered with status: ${response.status}`);
+ * console.log(`Region: ${response.region}`);
+ *
+ * // Display DNS records to configure
+ * response.records.forEach(recordGroup => {
+ *   if (recordGroup.TXT) {
+ *     console.log("TXT Records to add:");
+ *     recordGroup.TXT.forEach(record => {
+ *       console.log(`  ${record.name}: ${record.value} (${record.purpose})`);
+ *     });
+ *   }
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Register domain with custom settings
+ * const response = await contiguity.domains.register({
+ *   domain: "example.com",
+ *   region: "us-east-1",
+ *   custom_return_path: "mail"
+ * });
+ *
+ * console.log(`Created at: ${new Date(response.created_at).toISOString()}`);
+ * ```
+ */
+export async function _domainsRegister(params) {
+    const validatedParams = DomainsRegisterRequest.parse(params);
+    const { domain, ...bodyParams } = validatedParams;
+    const response = await this.request(`/domains/${encodeURIComponent(domain)}`, {
+        method: "POST",
+        body: JSON.stringify(bodyParams),
+    });
+    return this.parse({
+        response,
+        schemas: {
+            sdk: DomainsRegisterResponse,
+            raw: DomainsRegisterResponseBuilder.raw
+        }
+    });
+}