@land-catalyst/batch-data-sdk 1.1.12

package/dist/client.js

@@ -0,0 +1,757 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchDataClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const logger_interface_1 = require("./logger.interface");
+const builders_1 = require("./builders");
+/**
+ * BatchData API Client
+ *
+ * Pure API client that makes HTTP calls to BatchData.io endpoints.
+ * No business logic - just handles HTTP communication with the API.
+ */
+class BatchDataClient {
+    constructor(options) {
+        // Validate API key is present
+        if (!options.apiKey) {
+            throw new Error("BatchData API key is required. Please provide apiKey in options.");
+        }
+        this.v1BaseUrl = options.v1BaseUrl || "https://api.batchdata.com/api/v1";
+        this.v2BaseUrl = options.v2BaseUrl || "https://api.batchdata.com/api/v2";
+        this.v3BaseUrl = options.v3BaseUrl || "https://api.batchdata.com/api/v3";
+        this.logger = options.logger || new logger_interface_1.ConsoleLogger();
+        this.webhooks = options.webhooks;
+        this.axiosInstance = axios_1.default.create({
+            timeout: options.timeout || 30000,
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json",
+                Authorization: `Bearer ${options.apiKey}`,
+            },
+        });
+        // Set up middleware/interceptors if provided
+        if (options.middleware) {
+            this.setupMiddleware(options.middleware);
+        }
+    }
+    /**
+     * Set up axios interceptors from middleware configuration
+     * @param middleware The middleware configuration
+     */
+    setupMiddleware(middleware) {
+        // Request interceptors
+        if (middleware.onRequest && middleware.onRequest.length > 0) {
+            middleware.onRequest.forEach((middlewareFn) => {
+                this.axiosInstance.interceptors.request.use((config) => middlewareFn(config), undefined // Request errors are handled by response error interceptors
+                );
+            });
+        }
+        // Response interceptors
+        if (middleware.onResponse && middleware.onResponse.length > 0) {
+            middleware.onResponse.forEach((middlewareFn) => {
+                this.axiosInstance.interceptors.response.use((response) => middlewareFn(response), undefined // Errors are handled by error interceptors
+                );
+            });
+        }
+        // Error interceptors
+        if (middleware.onError && middleware.onError.length > 0) {
+            middleware.onError.forEach((middlewareFn) => {
+                this.axiosInstance.interceptors.response.use(undefined, // Success responses are handled by response interceptors
+                async (error) => {
+                    const result = await middlewareFn(error);
+                    // If middleware returns a response, treat it as recovery
+                    if (result && "status" in result && "data" in result) {
+                        return result;
+                    }
+                    // Otherwise, re-throw the error
+                    throw result;
+                });
+            });
+        }
+    }
+    /**
+     * Apply default webhook URLs to an async request if they're not already set.
+     * This helper ensures that if webhook URLs are configured in the client,
+     * they will be used for async requests that don't explicitly specify webhook URLs.
+     *
+     * @param request The async request to modify
+     * @param endpointType The type of async endpoint (e.g., 'propertyLookup', 'propertySearch')
+     * @returns The request with webhook URLs applied (if needed)
+     */
+    applyDefaultWebhookUrls(request, endpointType) {
+        // Determine which webhook URLs to use
+        let webhookUrl;
+        let errorWebhookUrl;
+        // First, try endpoint-specific webhook config
+        if (endpointType && this.webhooks?.[endpointType]) {
+            webhookUrl = this.webhooks[endpointType]?.url;
+            errorWebhookUrl = this.webhooks[endpointType]?.errorUrl;
+        }
+        // Fall back to default webhook config
+        if (!webhookUrl && this.webhooks?.default) {
+            webhookUrl = this.webhooks.default.url;
+            errorWebhookUrl = errorWebhookUrl || this.webhooks.default.errorUrl;
+        }
+        // If no webhook URLs are configured, return original request
+        if (!webhookUrl && !errorWebhookUrl) {
+            return request;
+        }
+        // If request has no options, create an empty options object
+        const options = request.options || {};
+        // Apply webhook URL if not already set
+        if (!options.webhookUrl && webhookUrl) {
+            options.webhookUrl = webhookUrl;
+        }
+        // Apply error webhook URL if not already set
+        if (!options.errorWebhookUrl && errorWebhookUrl) {
+            options.errorWebhookUrl = errorWebhookUrl;
+        }
+        // If no options were modified and request had no options, return original
+        if (!request.options && !options.webhookUrl && !options.errorWebhookUrl) {
+            return request;
+        }
+        // Return a new request object with updated options
+        return {
+            ...request,
+            options: {
+                ...request.options,
+                ...options,
+            },
+        };
+    }
+    /**
+     * Apply default webhook URLs to a property subscription request if they're not already set.
+     * This helper ensures that if webhook URLs are configured in the client,
+     * they will be used for property subscriptions that don't explicitly specify webhook URLs.
+     *
+     * @param request The property subscription request to modify
+     * @returns The request with webhook URLs applied (if needed)
+     */
+    applyPropertySubscriptionWebhooks(request) {
+        // Determine which webhook URLs to use
+        let webhookUrl;
+        let errorWebhookUrl;
+        // First, try property subscription-specific webhook config
+        if (this.webhooks?.propertySubscription) {
+            webhookUrl = this.webhooks.propertySubscription.url;
+            errorWebhookUrl = this.webhooks.propertySubscription.errorUrl;
+        }
+        // Fall back to default webhook config
+        if (!webhookUrl && this.webhooks?.default) {
+            webhookUrl = this.webhooks.default.url;
+            errorWebhookUrl = errorWebhookUrl || this.webhooks.default.errorUrl;
+        }
+        // If no webhook URLs are configured, return original request
+        if (!webhookUrl && !errorWebhookUrl) {
+            return request;
+        }
+        // If deliveryConfig is not set or is not a webhook type, create/update it
+        const deliveryConfig = request.deliveryConfig || {
+            type: "webhook",
+        };
+        // Only apply defaults if deliveryConfig is a webhook type
+        if (deliveryConfig.type === "webhook") {
+            // Apply webhook URL if not already set
+            if (!deliveryConfig.url && webhookUrl) {
+                deliveryConfig.url = webhookUrl;
+            }
+            // Apply error webhook URL if not already set
+            if (!deliveryConfig.errorUrl && errorWebhookUrl) {
+                deliveryConfig.errorUrl = errorWebhookUrl;
+            }
+        }
+        // Return a new request object with updated deliveryConfig
+        return {
+            ...request,
+            deliveryConfig: {
+                ...deliveryConfig,
+            },
+        };
+    }
+    /**
+     * Add a request middleware function that executes before requests are sent.
+     * Useful for adding headers, logging, metrics, etc.
+     *
+     * @param middleware The middleware function
+     * @returns The interceptor ID (can be used to remove the interceptor later)
+     *
+     * @example
+     * ```typescript
+     * const client = new BatchDataClient({ apiKey: "..." });
+     * client.addRequestMiddleware((config) => {
+     *   console.log(`Making request to ${config.url}`);
+     *   config.headers["X-Custom-Header"] = "value";
+     *   return config;
+     * });
+     * ```
+     */
+    addRequestMiddleware(middleware) {
+        return this.axiosInstance.interceptors.request.use((config) => middleware(config), undefined);
+    }
+    /**
+     * Add a response middleware function that executes after successful responses.
+     * Useful for logging, metrics, response transformation, etc.
+     *
+     * @param middleware The middleware function
+     * @returns The interceptor ID (can be used to remove the interceptor later)
+     *
+     * @example
+     * ```typescript
+     * const client = new BatchDataClient({ apiKey: "..." });
+     * client.addResponseMiddleware((response) => {
+     *   console.log(`Received response: ${response.status}`);
+     *   return response;
+     * });
+     * ```
+     */
+    addResponseMiddleware(middleware) {
+        return this.axiosInstance.interceptors.response.use((response) => middleware(response), undefined);
+    }
+    /**
+     * Add an error middleware function that executes when requests fail.
+     * Useful for error handling, retry logic, error transformation, etc.
+     *
+     * @param middleware The middleware function
+     * @returns The interceptor ID (can be used to remove the interceptor later)
+     *
+     * @example
+     * ```typescript
+     * const client = new BatchDataClient({ apiKey: "..." });
+     * client.addErrorMiddleware(async (error) => {
+     *   if (error.response?.status === 429) {
+     *     // Retry logic here
+     *   }
+     *   throw error; // Re-throw to propagate
+     * });
+     * ```
+     */
+    addErrorMiddleware(middleware) {
+        return this.axiosInstance.interceptors.response.use(undefined, async (error) => {
+            const result = await middleware(error);
+            // If middleware returns a response, treat it as recovery
+            if (result && "status" in result && "data" in result) {
+                return result;
+            }
+            // Otherwise, re-throw the error
+            throw result;
+        });
+    }
+    /**
+     * Remove a request interceptor by ID
+     * @param id The interceptor ID returned from addRequestMiddleware
+     */
+    removeRequestMiddleware(id) {
+        this.axiosInstance.interceptors.request.eject(id);
+    }
+    /**
+     * Remove a response interceptor by ID
+     * @param id The interceptor ID returned from addResponseMiddleware or addErrorMiddleware
+     */
+    removeResponseMiddleware(id) {
+        this.axiosInstance.interceptors.response.eject(id);
+    }
+    /**
+     * Wrapper for axios calls that handles error logging consistently
+     * @param axiosCall The axios call to execute
+     * @param errorMessagePrefix Prefix for the error message (e.g., "Failed to search properties")
+     * @param url The URL being called (for error details)
+     * @returns Object containing the response data and status
+     */
+    async handleApiCall(axiosCall, errorMessagePrefix, url) {
+        try {
+            const response = await axiosCall();
+            return response;
+        }
+        catch (error) {
+            const axiosError = error;
+            const errorDetails = {
+                url,
+                status: axiosError.response?.status,
+                statusText: axiosError.response?.statusText,
+                data: axiosError.response?.data,
+                headers: axiosError.response?.headers,
+            };
+            this.logger.error(`${errorMessagePrefix}: ${axiosError.response?.status} - ${axiosError.message}`, axiosError, errorDetails);
+            throw error;
+        }
+    }
+    /**
+     * Create a property subscription (v2 API)
+     * POST /api/v2/property-subscription
+     */
+    async createPropertySubscription(request) {
+        const url = `${this.v2BaseUrl}/property-subscription`;
+        // Apply default webhook URLs if configured
+        const requestWithDefaults = this.applyPropertySubscriptionWebhooks(request);
+        this.logger.debug(`Creating property subscription: POST ${url}`, {
+            query: requestWithDefaults.searchCriteria.query,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, requestWithDefaults), "Failed to create property subscription", url);
+        this.logger.debug(`Property subscription created: ${data.id}`, {
+            status,
+        });
+        return data;
+    }
+    /**
+     * Search for properties (v1 API)
+     * POST /api/v1/property/search
+     *
+     * @param searchCriteria Search criteria
+     * @param options Request options
+     * @param options.take Number of properties to return (0 for count-only)
+     * @param options.skip Number of properties to skip for pagination
+     * @returns Property search API response
+     */
+    async searchProperties(request) {
+        const url = `${this.v1BaseUrl}/property/search`;
+        this.logger.debug(`Searching properties: POST ${url}`, {
+            query: request.searchCriteria.query,
+            take: request.options?.take,
+            skip: request.options?.skip,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, request), "Failed to search properties", url);
+        this.logger.debug(`Property search completed`, {
+            status,
+            hasData: !!data,
+        });
+        return data;
+    }
+    /**
+     * Get the count of properties matching the search criteria
+     * @param searchCriteria Search criteria to match properties
+     * @returns Number of matching properties, or null if the endpoint is unavailable
+     */
+    async getPropertyCount(searchRequest) {
+        const { searchCriteria, options } = searchRequest;
+        const lookupOptions = options
+            ? builders_1.PropertyLookupOptionsBuilder.from(options).take(0)
+            : new builders_1.PropertyLookupOptionsBuilder();
+        const response = await this.searchProperties({
+            searchCriteria,
+            options: lookupOptions.build(),
+        });
+        return response.results?.meta?.results?.resultsFound ?? null;
+    }
+    /**
+     * Verify and normalize addresses (v1 API)
+     * POST /api/v1/address/verify
+     *
+     * @param request Address verification request
+     * @returns Address verification API response
+     */
+    async verifyAddress(request) {
+        const url = `${this.v1BaseUrl}/address/verify`;
+        this.logger.debug(`Verifying addresses: POST ${url}`, {
+            requestCount: request.requests.length,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, request), "Failed to verify addresses", url);
+        this.logger.debug(`Address verification completed`, {
+            status,
+            addressCount: data.results?.addresses?.length,
+        });
+        return data;
+    }
+    /**
+     * Get address autocomplete suggestions (v1 API)
+     * POST /api/v1/address/autocomplete
+     *
+     * Note: This endpoint requires a Referer header per API documentation.
+     * For server-side usage, a default Referer is set.
+     *
+     * @param request Address autocomplete request
+     * @returns Address autocomplete API response
+     */
+    async autocompleteAddress(request) {
+        const url = `${this.v1BaseUrl}/address/autocomplete`;
+        this.logger.debug(`Autocompleting address: POST ${url}`, {
+            query: request.searchCriteria.query,
+            take: request.options?.take,
+        });
+        // Autocomplete endpoint requires Referer header per API documentation
+        // Set a default Referer for server-side SDK usage
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, request, {
+            headers: {
+                Referer: "https://api.batchdata.com",
+            },
+        }), "Failed to autocomplete address", url);
+        this.logger.debug(`Address autocomplete completed`, {
+            status,
+            suggestionCount: data.result?.suggestions?.length,
+        });
+        return data;
+    }
+    /**
+     * Geocode an address to coordinates (v1 API)
+     * POST /api/v1/address/geocode
+     *
+     * @param request Address geocode request
+     * @returns Address geocode API response
+     */
+    async geocodeAddress(request) {
+        const url = `${this.v1BaseUrl}/address/geocode`;
+        this.logger.debug(`Geocoding address: POST ${url}`, {
+            requestCount: request.requests.length,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, request), "Failed to geocode address", url);
+        this.logger.debug(`Address geocode completed`, {
+            status,
+            addressCount: data.result?.addresses?.length,
+        });
+        return data;
+    }
+    /**
+     * Reverse geocode coordinates to an address (v1 API)
+     * POST /api/v1/address/reverse-geocode
+     *
+     * @param request Address reverse geocode request
+     * @returns Address reverse geocode API response
+     */
+    async reverseGeocodeAddress(request) {
+        const url = `${this.v1BaseUrl}/address/reverse-geocode`;
+        this.logger.debug(`Reverse geocoding coordinates: POST ${url}`, {
+            latitude: request.request.latitude,
+            longitude: request.request.longitude,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, request), "Failed to reverse geocode address", url);
+        this.logger.debug(`Address reverse geocode completed`, {
+            status,
+            addressCount: data.result?.addresses?.length,
+        });
+        return data;
+    }
+    /**
+     * Lookup property details by address, propertyId, hash, or APN (v1 API)
+     * POST /api/v1/property/lookup/all-attributes
+     *
+     * @param request Property lookup request
+     * @returns Property lookup API response
+     */
+    async lookupProperty(request) {
+        const url = `${this.v1BaseUrl}/property/lookup/all-attributes`;
+        this.logger.debug(`Looking up property: POST ${url}`, {
+            requestCount: request.requests.length,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, request), "Failed to lookup property", url);
+        this.logger.debug(`Property lookup completed`, {
+            status,
+            propertyCount: data.results?.properties?.length,
+        });
+        return data;
+    }
+    /**
+     * Lookup property details asynchronously (v1 API)
+     * POST /api/v1/property/lookup/async
+     *
+     * @param request Property lookup async request
+     * @returns Property lookup async API response
+     */
+    async lookupPropertyAsync(request) {
+        const url = `${this.v1BaseUrl}/property/lookup/async`;
+        // Apply default webhook URLs if configured
+        const requestWithDefaults = this.applyDefaultWebhookUrls(request, "propertyLookup");
+        this.logger.debug(`Looking up property async: POST ${url}`, {
+            requestCount: requestWithDefaults.requests.length,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, requestWithDefaults), "Failed to lookup property async", url);
+        this.logger.debug(`Property lookup async completed`, {
+            status,
+            asyncStatus: data.status?.text,
+        });
+        return data;
+    }
+    /**
+     * Search for properties asynchronously (v1 API)
+     * POST /api/v1/property/search/async
+     *
+     * @param request Property search async request
+     * @returns Property search async API response
+     */
+    async searchPropertiesAsync(request) {
+        const url = `${this.v1BaseUrl}/property/search/async`;
+        // Apply default webhook URLs if configured
+        const requestWithDefaults = this.applyDefaultWebhookUrls(request, "propertySearch");
+        this.logger.debug(`Searching properties async: POST ${url}`, {
+            query: requestWithDefaults.searchCriteria.query,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, requestWithDefaults), "Failed to search properties async", url);
+        this.logger.debug(`Property search async completed`, {
+            status,
+            asyncStatus: data.status?.text,
+        });
+        return data;
+    }
+    /**
+     * Skip trace property owners (v1 API)
+     * POST /api/v1/property/skip-trace
+     *
+     * @param request Property skip trace request
+     * @returns Property skip trace API response
+     */
+    async skipTraceProperty(request) {
+        const url = `${this.v1BaseUrl}/property/skip-trace`;
+        this.logger.debug(`Skip tracing property: POST ${url}`, {
+            requestCount: request.requests.length,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, request), "Failed to skip trace property", url);
+        this.logger.debug(`Property skip trace completed`, {
+            status,
+            propertyCount: data.results?.properties?.length,
+        });
+        return data;
+    }
+    /**
+     * Skip trace property owners asynchronously (v1 API)
+     * POST /api/v1/property/skip-trace/async
+     *
+     * @param request Property skip trace async request
+     * @returns Property skip trace async API response
+     */
+    async skipTracePropertyAsync(request) {
+        const url = `${this.v1BaseUrl}/property/skip-trace/async`;
+        // Apply default webhook URLs if configured
+        const requestWithDefaults = this.applyDefaultWebhookUrls(request, "skipTrace");
+        this.logger.debug(`Skip tracing property async: POST ${url}`, {
+            requestCount: requestWithDefaults.requests.length,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, requestWithDefaults), "Failed to skip trace property async", url);
+        this.logger.debug(`Property skip trace async completed`, {
+            status,
+            asyncStatus: data.status?.text,
+        });
+        return data;
+    }
+    /**
+     * Verify phone numbers (v1 API)
+     * POST /api/v1/phone/verification
+     *
+     * @param request Phone verification request
+     * @returns Phone verification API response
+     */
+    async verifyPhone(request) {
+        const url = `${this.v1BaseUrl}/phone/verification`;
+        this.logger.debug(`Verifying phone: POST ${url}`, {
+            requestCount: request.requests.length,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, request), "Failed to verify phone", url);
+        this.logger.debug(`Phone verification completed`, {
+            status,
+            phoneCount: data.results?.phoneNumbers?.length,
+        });
+        return data;
+    }
+    /**
+     * Verify phone numbers asynchronously (v1 API)
+     * POST /api/v1/phone/verification/async
+     *
+     * @param request Phone verification async request
+     * @returns Phone verification async API response
+     */
+    async verifyPhoneAsync(request) {
+        const url = `${this.v1BaseUrl}/phone/verification/async`;
+        // Apply default webhook URLs if configured
+        const requestWithDefaults = this.applyDefaultWebhookUrls(request, "phoneVerification");
+        this.logger.debug(`Verifying phone async: POST ${url}`, {
+            requestCount: requestWithDefaults.requests.length,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, requestWithDefaults), "Failed to verify phone async", url);
+        this.logger.debug(`Phone verification async completed`, {
+            status,
+            asyncStatus: data.status?.text,
+        });
+        return data;
+    }
+    /**
+     * Check phone numbers against DNC (Do Not Call) list (v1 API)
+     * POST /api/v1/phone/dnc
+     *
+     * @param request Phone DNC request
+     * @returns Phone DNC API response
+     */
+    async checkPhoneDNC(request) {
+        const url = `${this.v1BaseUrl}/phone/dnc`;
+        this.logger.debug(`Checking phone DNC: POST ${url}`, {
+            requestCount: request.requests.length,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, request), "Failed to check phone DNC", url);
+        this.logger.debug(`Phone DNC check completed`, {
+            status,
+            phoneCount: data.results?.phoneNumbers?.length,
+        });
+        return data;
+    }
+    /**
+     * Check phone numbers against DNC list asynchronously (v1 API)
+     * POST /api/v1/phone/dnc/async
+     *
+     * @param request Phone DNC async request
+     * @returns Phone DNC async API response
+     */
+    async checkPhoneDNCAsync(request) {
+        const url = `${this.v1BaseUrl}/phone/dnc/async`;
+        // Apply default webhook URLs if configured
+        const requestWithDefaults = this.applyDefaultWebhookUrls(request, "phoneDNC");
+        this.logger.debug(`Checking phone DNC async: POST ${url}`, {
+            requestCount: requestWithDefaults.requests.length,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, requestWithDefaults), "Failed to check phone DNC async", url);
+        this.logger.debug(`Phone DNC check async completed`, {
+            status,
+            asyncStatus: data.status?.text,
+        });
+        return data;
+    }
+    /**
+     * Check phone numbers for TCPA compliance (v1 API)
+     * POST /api/v1/phone/tcpa
+     *
+     * @param request Phone TCPA request
+     * @returns Phone TCPA API response
+     */
+    async checkPhoneTCPA(request) {
+        const url = `${this.v1BaseUrl}/phone/tcpa`;
+        this.logger.debug(`Checking phone TCPA: POST ${url}`, {
+            requestCount: request.requests.length,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, request), "Failed to check phone TCPA", url);
+        this.logger.debug(`Phone TCPA check completed`, {
+            status,
+            phoneCount: data.results?.phoneNumbers?.length,
+        });
+        return data;
+    }
+    /**
+     * Check phone numbers for TCPA compliance asynchronously (v1 API)
+     * POST /api/v1/phone/tcpa/async
+     *
+     * @param request Phone TCPA async request
+     * @returns Phone TCPA async API response
+     */
+    async checkPhoneTCPAAsync(request) {
+        const url = `${this.v1BaseUrl}/phone/tcpa/async`;
+        // Apply default webhook URLs if configured
+        const requestWithDefaults = this.applyDefaultWebhookUrls(request, "phoneTCPA");
+        this.logger.debug(`Checking phone TCPA async: POST ${url}`, {
+            requestCount: requestWithDefaults.requests.length,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, requestWithDefaults), "Failed to check phone TCPA async", url);
+        this.logger.debug(`Phone TCPA check async completed`, {
+            status,
+            asyncStatus: data.status?.text,
+        });
+        return data;
+    }
+    /**
+     * Get all property subscriptions (v2 API)
+     * GET /api/v2/property-subscription
+     *
+     * @returns Array of property subscriptions
+     */
+    async getPropertySubscriptions() {
+        const url = `${this.v2BaseUrl}/property-subscription`;
+        this.logger.debug(`Getting property subscriptions: GET ${url}`);
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.get(url), "Failed to get property subscriptions", url);
+        this.logger.debug(`Get property subscriptions completed`, {
+            status,
+            subscriptionCount: Array.isArray(data) ? data.length : 0,
+        });
+        return data;
+    }
+    /**
+     * Get property subscription by ID (v2 API)
+     * GET /api/v2/property-subscription/{id}
+     *
+     * @param id Subscription ID
+     * @returns Property subscription detail
+     */
+    async getPropertySubscription(id) {
+        const url = `${this.v2BaseUrl}/property-subscription/${id}`;
+        this.logger.debug(`Getting property subscription: GET ${url}`, {
+            subscriptionId: id,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.get(url), "Failed to get property subscription", url);
+        this.logger.debug(`Get property subscription completed`, {
+            status,
+            hasSubscription: !!data.results?.subscription,
+        });
+        return data;
+    }
+    /**
+     * Delete property subscription (v2 API)
+     * DELETE /api/v2/property-subscription/{id}
+     *
+     * @param id Subscription ID
+     * @returns Delete response
+     */
+    async deletePropertySubscription(id) {
+        const url = `${this.v2BaseUrl}/property-subscription/${id}`;
+        this.logger.debug(`Deleting property subscription: DELETE ${url}`, {
+            subscriptionId: id,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.delete(url), "Failed to delete property subscription", url);
+        this.logger.debug(`Delete property subscription completed`, {
+            status,
+        });
+        return data;
+    }
+    /**
+     * Get property permits (v2 API)
+     * POST /api/v2/property/get-property-permits
+     *
+     * @param request Property permit request
+     * @returns Property permit API response
+     */
+    async getPropertyPermit(request) {
+        const url = `${this.v2BaseUrl}/property/get-property-permits`;
+        this.logger.debug(`Getting property permits: POST ${url}`);
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, request), "Failed to get property permits", url);
+        this.logger.debug(`Get property permits completed`, {
+            status,
+            permitCount: data.result?.permits?.length,
+        });
+        return data;
+    }
+    /**
+     * Skip trace property owners (v3 API)
+     * POST /api/v3/property/skip-trace
+     *
+     * @param request Property skip trace v3 request
+     * @returns Property skip trace v3 API response
+     */
+    async skipTracePropertyV3(request) {
+        const url = `${this.v3BaseUrl}/property/skip-trace`;
+        this.logger.debug(`Skip tracing property v3: POST ${url}`, {
+            requestCount: request.requests.length,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, request), "Failed to skip trace property v3", url);
+        this.logger.debug(`Property skip trace v3 completed`, {
+            status,
+            dataCount: data.result?.data?.length,
+        });
+        return data;
+    }
+    /**
+     * Skip trace property owners asynchronously (v3 API)
+     * POST /api/v3/property/skip-trace/async
+     *
+     * @param request Property skip trace v3 async request
+     * @returns Property skip trace v3 async API response
+     */
+    async skipTracePropertyV3Async(request) {
+        const url = `${this.v3BaseUrl}/property/skip-trace/async`;
+        // Apply default webhook URLs if configured
+        const requestWithDefaults = this.applyDefaultWebhookUrls(request, "skipTraceV3");
+        this.logger.debug(`Skip tracing property v3 async: POST ${url}`, {
+            requestCount: requestWithDefaults.requests.length,
+        });
+        const { data, status } = await this.handleApiCall(() => this.axiosInstance.post(url, requestWithDefaults), "Failed to skip trace property v3 async", url);
+        this.logger.debug(`Property skip trace v3 async completed`, {
+            status,
+            requestId: data.result?.requestId,
+        });
+        return data;
+    }
+}
+exports.BatchDataClient = BatchDataClient;