contiguity 0.0.9 → 0.1.0

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

@@ -0,0 +1,28 @@
+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 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;AAExB,eAAO,MAAM,oBAAoB;;iBAG/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;iBAKhC,CAAC;AAKH,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,CAUzF"}

package/dist/services/domains/delete.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+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(),
+});
+/**
+ * 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,
+        schema: DomainsDeleteResponse
+    });
+}

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

@@ -0,0 +1,98 @@
+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 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;AAGxB,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;AAKH,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,CAUnF"}

package/dist/services/domains/get.js

@@ -0,0 +1,89 @@
+import { z } from "zod";
+// 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,
+});
+/**
+ * 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,
+        schema: DomainsGetResponse
+    });
+}

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,36 @@
+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 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;AAGxB,eAAO,MAAM,UAAU;;;;;;;iBAarB,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;iBAG9B,CAAC;AAIH,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,CAS1D"}

package/dist/services/domains/list.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+// 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),
+});
+/**
+ * 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,
+        schema: DomainsListResponse
+    });
+}

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

@@ -0,0 +1,67 @@
+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 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;AAGxB,eAAO,MAAM,sBAAsB;;;;iBAOjC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;iBASlC,CAAC;AAKH,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,CAa7F"}

package/dist/services/domains/register.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+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(),
+});
+/**
+ * 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,
+        schema: DomainsRegisterResponse
+    });
+}

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

@@ -0,0 +1,17 @@
+import { ContiguityClient } from "@/client/fetch";
+import { z } from "zod";
+import { EmailSendRequest, EmailResponse } from "@/services/email/send";
+import type { WithMetadata } from "@/types/metadata";
+export type EmailSendParams = z.infer<typeof EmailSendRequest>;
+export type EmailSendResponse = z.infer<typeof EmailResponse>;
+/**
+ * Email service for sending emails
+ */
+export declare class EmailService extends ContiguityClient {
+    constructor(token: string);
+    /**
+     * Send an email
+     */
+    send(params: EmailSendParams): Promise<WithMetadata<EmailSendResponse>>;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/email/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC/D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE9D;;GAEG;AACH,qBAAa,YAAa,SAAQ,gBAAgB;gBAClC,KAAK,EAAE,MAAM;IAIzB;;OAEG;IACG,IAAI,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC;CAGhF"}

package/dist/services/email/index.js

@@ -0,0 +1,16 @@
+import { ContiguityClient } from "@/client/fetch";
+import { _emailSend } from "@/services/email/send";
+/**
+ * Email service for sending emails
+ */
+export class EmailService extends ContiguityClient {
+    constructor(token) {
+        super(token);
+    }
+    /**
+     * Send an email
+     */
+    async send(params) {
+        return _emailSend.call(this, params);
+    }
+}

package/dist/services/email/send.d.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+export declare const EmailSendRequest: z.ZodObject<{
+    to: z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodEmail>]>;
+    from: z.ZodString;
+    subject: z.ZodString;
+    body: z.ZodObject<{
+        text: z.ZodOptional<z.ZodString>;
+        html: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    reply_to: z.ZodOptional<z.ZodString>;
+    cc: z.ZodOptional<z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodEmail>]>>;
+    bcc: z.ZodOptional<z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodEmail>]>>;
+    headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const EmailResponse: z.ZodObject<{
+    email_id: z.ZodString;
+}, z.core.$strip>;
+export type EmailBodyParams = {
+    text?: string;
+    html?: string;
+};
+export type EmailHeaderParams = {
+    name: string;
+    value: string;
+};
+export type EmailSendParams = z.infer<typeof EmailSendRequest>;
+export type EmailSendResponseType = z.infer<typeof EmailResponse>;
+/**
+ * Sends an email
+ *
+ * @example
+ * ```typescript
+ * const response = await contiguity.email.send({
+ *   to: "recipient@example.com",
+ *   from: "Contiguity <no-reply@contiguity.com>",
+ *   subject: "Hello from Contiguity!",
+ *   body: {
+ *     text: "Hello, world!",
+ *     html: "<p>Hello, world!</p>"
+ *   }
+ * });
+ * console.log(`Email ID: ${response.email_id}`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Send to multiple recipients with CC and BCC
+ * const response = await contiguity.email.send({
+ *   to: ["user1@example.com", "user2@example.com"],
+ *   from: "Your Company <no-reply@yourcompany.com>",
+ *   subject: "Newsletter Update",
+ *   body: {
+ *     html: "<h1>Newsletter</h1><p>Latest updates...</p>"
+ *   },
+ *   cc: "manager@example.com",
+ *   bcc: ["analytics@company.com"],
+ *   reply_to: "support@yourcompany.com"
+ * });
+ * console.log(`Email ID: ${response.email_id}`);
+ * ```
+ */
+export declare function _emailSend(this: any, params: EmailSendParams): Promise<any>;
+//# sourceMappingURL=send.d.ts.map

package/dist/services/email/send.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send.d.ts","sourceRoot":"","sources":["../../../src/services/email/send.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;iBA8B3B,CAAA;AAEF,eAAO,MAAM,aAAa;;iBAExB,CAAA;AAIF,MAAM,MAAM,eAAe,GAAG;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC/D,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC,CAWjF"}