@land-catalyst/batch-data-sdk 1.1.12

package/dist/types.d.ts

@@ -0,0 +1,1738 @@
+/**
+ * BatchData.io API Types
+ *
+ * Complete TypeScript type definitions for the BatchData Property Subscription API v2
+ *
+ * API Documentation: https://developer.batchdata.com/docs/batchdata/batchdata-v2/operations/create-a-property-subscription
+ */
+/**
+ * String filter operators for text-based search criteria
+ */
+export interface StringFilter {
+    equals?: string;
+    contains?: string;
+    startsWith?: string;
+    endsWith?: string;
+    inList?: string[];
+    notInList?: string[];
+    matches?: string[];
+}
+/**
+ * Numeric range filter for numeric search criteria
+ */
+export interface NumericRangeFilter {
+    min?: number;
+    max?: number;
+}
+/**
+ * Date range filter for date-based search criteria
+ */
+export interface DateRangeFilter {
+    minDate?: string;
+    maxDate?: string;
+}
+/**
+ * Geographic point (latitude/longitude)
+ */
+export interface GeoPoint {
+    latitude: number;
+    longitude: number;
+}
+/**
+ * Geographic distance filter
+ */
+export interface GeoLocationDistance {
+    geoPoint: GeoPoint;
+    distanceMeters?: string;
+    distanceKilometers?: string;
+    distanceFeet?: string;
+    distanceYards?: string;
+    distanceMiles?: string;
+}
+/**
+ * Geographic bounding box filter
+ */
+export interface GeoLocationBoundingBox {
+    nwGeoPoint: GeoPoint;
+    seGeoPoint: GeoPoint;
+}
+/**
+ * Geographic polygon filter
+ */
+export interface GeoLocationPolygon {
+    geoPoints: GeoPoint[];
+}
+/**
+ * Address search criteria
+ */
+export interface AddressSearchCriteria {
+    street?: StringFilter;
+    city?: StringFilter;
+    locality?: StringFilter;
+    county?: StringFilter;
+    countyFipsCode?: StringFilter;
+    state?: StringFilter;
+    zip?: StringFilter;
+    unitType?: StringFilter;
+    formattedStreet?: StringFilter;
+    streetNoUnit?: StringFilter;
+    geoLocationDistance?: GeoLocationDistance;
+    geoLocationBoundingBox?: GeoLocationBoundingBox;
+    geoLocationPolygon?: GeoLocationPolygon;
+    initialGeoStatus?: StringFilter;
+    geoStatus?: StringFilter;
+    cityState?: StringFilter;
+    countyState?: StringFilter;
+}
+/**
+ * Assessment search criteria
+ */
+export interface AssessmentSearchCriteria {
+    assessmentYear?: NumericRangeFilter;
+    totalAssessedValue?: NumericRangeFilter;
+    assessedImprovementValue?: NumericRangeFilter;
+    assessedLandValue?: NumericRangeFilter;
+    marketValueYear?: NumericRangeFilter;
+    landMarketValue?: NumericRangeFilter;
+    improvementMarketValue?: NumericRangeFilter;
+    totalMarketValue?: NumericRangeFilter;
+}
+/**
+ * Building search criteria
+ */
+export interface BuildingSearchCriteria {
+    airConditioningSource?: StringFilter;
+    basementType?: StringFilter;
+    totalBuildingAreaSquareFeet?: NumericRangeFilter;
+    buildingClass?: StringFilter;
+    buildingCondition?: StringFilter;
+    buildingQuality?: StringFilter;
+    buildingType?: StringFilter;
+    driveway?: StringFilter;
+    exteriorWalls?: StringFilter;
+    floorCover?: StringFilter;
+    garageParkingSpaceCount?: NumericRangeFilter;
+    garage?: StringFilter;
+    heatSource?: StringFilter;
+    heatingFuelType?: StringFilter;
+    interiorWalls?: StringFilter;
+    buildingCount?: NumericRangeFilter;
+    bathroomCount?: NumericRangeFilter;
+    calculatedBathroomCount?: NumericRangeFilter;
+    bedroomCount?: NumericRangeFilter;
+    patio?: StringFilter;
+    storyCount?: NumericRangeFilter;
+    features?: StringFilter;
+    residentialUnitCount?: NumericRangeFilter;
+    pool?: StringFilter;
+    porch?: StringFilter;
+    roofCover?: StringFilter;
+    roofType?: StringFilter;
+    sewer?: StringFilter;
+    style?: StringFilter;
+    roomCount?: NumericRangeFilter;
+    unitCount?: NumericRangeFilter;
+    constructionType?: StringFilter;
+    waterService?: StringFilter;
+    yearBuilt?: NumericRangeFilter;
+}
+/**
+ * Comp address search criteria
+ */
+export interface CompAddressSearchCriteria {
+    street?: string;
+    city?: string;
+    state?: string;
+    zip?: string;
+    hash?: string;
+}
+/**
+ * Demographics search criteria
+ */
+export interface DemographicsSearchCriteria {
+    age?: NumericRangeFilter;
+    householdSize?: NumericRangeFilter;
+    income?: NumericRangeFilter;
+    netWorth?: NumericRangeFilter;
+    discretionaryIncome?: NumericRangeFilter;
+    homeownerRenter?: StringFilter;
+    businessOwner?: StringFilter;
+    gender?: StringFilter;
+    hasChildren?: {
+        equals: boolean;
+    };
+    investments?: StringFilter;
+    demographics?: StringFilter;
+    religiousAffiliation?: StringFilter;
+}
+/**
+ * Foreclosure search criteria
+ */
+export interface ForeclosureSearchCriteria {
+    status?: StringFilter;
+    recordingDate?: DateRangeFilter;
+    auctionDate?: DateRangeFilter;
+    releaseDate?: DateRangeFilter;
+    auctionMinimumBidAmount?: NumericRangeFilter;
+    pastDueAmount?: NumericRangeFilter;
+}
+/**
+ * General property search criteria
+ */
+export interface GeneralSearchCriteria {
+    propertyTypeCategory?: StringFilter;
+    propertyTypeDetail?: StringFilter;
+}
+/**
+ * IDs search criteria
+ */
+export interface IdsSearchCriteria {
+    addressHash?: StringFilter;
+    mailingAddressHash?: StringFilter;
+    fipsCode?: StringFilter;
+    apn?: StringFilter;
+    taxId?: StringFilter;
+}
+/**
+ * Intel search criteria
+ */
+export interface IntelSearchCriteria {
+    lastSoldDate?: DateRangeFilter;
+    lastSoldPrice?: NumericRangeFilter;
+    salePropensity?: NumericRangeFilter;
+}
+/**
+ * Involuntary lien search criteria
+ */
+export interface InvoluntaryLienSearchCriteria {
+    lienType?: StringFilter;
+    lienTypeCode?: StringFilter;
+    documentType?: StringFilter;
+    documentTypeCode?: StringFilter;
+    recordingDate?: DateRangeFilter;
+    filingDate?: DateRangeFilter;
+    lienAmount?: NumericRangeFilter;
+}
+/**
+ * Legal search criteria
+ */
+export interface LegalSearchCriteria {
+    subdivisionName?: StringFilter;
+}
+/**
+ * Listing search criteria
+ */
+export interface ListingSearchCriteria {
+    description?: StringFilter;
+    price?: NumericRangeFilter;
+    daysOnMarket?: NumericRangeFilter;
+    status?: StringFilter;
+    statusCategory?: StringFilter;
+    failedListingDate?: DateRangeFilter;
+    soldDate?: DateRangeFilter;
+}
+/**
+ * Lot search criteria
+ */
+export interface LotSearchCriteria {
+    lotSizeAcres?: NumericRangeFilter;
+    lotDepthFeet?: NumericRangeFilter;
+    lotFrontageFeet?: NumericRangeFilter;
+    lotSizeSquareFeet?: NumericRangeFilter;
+    zoningCode?: StringFilter;
+}
+/**
+ * Open lien search criteria
+ */
+export interface OpenLienSearchCriteria {
+    allLoanTypes?: StringFilter;
+    juniorLoanTypes?: StringFilter;
+    totalOpenLienCount?: NumericRangeFilter;
+    totalOpenLienBalance?: NumericRangeFilter;
+    firstLoanLtv?: NumericRangeFilter;
+    firstLoanInterestRate?: NumericRangeFilter;
+    secondLoanInterestRate?: NumericRangeFilter;
+    thirdLoanInterestRate?: NumericRangeFilter;
+    fourthLoanInterestRate?: NumericRangeFilter;
+    firstLoanType?: StringFilter;
+    secondLoanType?: StringFilter;
+    thirdLoanType?: StringFilter;
+    fourthLoanType?: StringFilter;
+    firstLoanRecordingDate?: DateRangeFilter;
+    lastLoanRecordingDate?: DateRangeFilter;
+}
+/**
+ * Owner search criteria
+ */
+export interface OwnerSearchCriteria {
+    firstName?: StringFilter;
+    lastName?: StringFilter;
+    ownerOccupied?: {
+        equals: boolean;
+    };
+    mailingStreet?: StringFilter;
+    mailingCity?: StringFilter;
+    mailingState?: StringFilter;
+    mailingZip?: StringFilter;
+    ownerStatusType?: StringFilter;
+    lengthOfResidenceMonths?: NumericRangeFilter;
+    lengthOfResidenceYears?: NumericRangeFilter;
+    ownershipStartDate?: DateRangeFilter;
+    mailingAddressHash?: StringFilter;
+}
+/**
+ * Permit search criteria
+ */
+export interface PermitSearchCriteria {
+    permitCount?: NumericRangeFilter;
+    latestDate?: DateRangeFilter;
+    earliestDate?: DateRangeFilter;
+    totalJobValue?: NumericRangeFilter;
+    allTags?: StringFilter;
+}
+/**
+ * Property owner profile search criteria
+ */
+export interface PropertyOwnerProfileSearchCriteria {
+    propertiesCount?: NumericRangeFilter;
+    propertiesTotalEquity?: NumericRangeFilter;
+    propertiesTotalEstimatedValue?: NumericRangeFilter;
+    mortgagesTotalBalance?: NumericRangeFilter;
+    mortgagesCount?: NumericRangeFilter;
+    mortgagesAverageBalance?: NumericRangeFilter;
+}
+/**
+ * Sale search criteria
+ */
+export interface SaleSearchCriteria {
+    lastSalePrice?: NumericRangeFilter;
+    lastSaleDate?: DateRangeFilter;
+    lastSaleDocumentType?: StringFilter;
+    lastSalePricePerSquareFoot?: NumericRangeFilter;
+    flipLength?: NumericRangeFilter;
+    flipLengthCategory?: NumericRangeFilter;
+    flipProfit?: NumericRangeFilter;
+}
+/**
+ * Tax search criteria
+ */
+export interface TaxSearchCriteria {
+    taxDelinquentYear?: NumericRangeFilter;
+}
+/**
+ * Valuation search criteria
+ */
+export interface ValuationSearchCriteria {
+    estimatedValue?: NumericRangeFilter;
+    ltv?: NumericRangeFilter;
+    equityPercent?: NumericRangeFilter;
+}
+/**
+ * OR criteria - allows OR logic for specific fields
+ */
+export interface OrSearchCriteria {
+    listing?: {
+        status?: StringFilter;
+    };
+    sale?: {
+        lastSaleDate?: DateRangeFilter;
+    };
+}
+/**
+ * Valid quickList values (without "not-" prefix)
+ * Note: According to API docs, "involuntary-lien" is only listed for quickLists/orQuickLists arrays,
+ * but it's included here for consistency. If the API rejects it for quickList, it can be removed.
+ */
+export type QuickListValue = "absentee-owner" | "active-auction" | "active-listing" | "canceled-listing" | "cash-buyer" | "corporate-owned" | "expired-listing" | "failed-listing" | "fix-and-flip" | "free-and-clear" | "for-sale-by-owner" | "has-hoa" | "has-hoa-fees" | "high-equity" | "inherited" | "involuntary-lien" | "in-state-absentee-owner" | "listed-below-market-price" | "low-equity" | "mailing-address-vacant" | "notice-of-default" | "notice-of-lis-pendens" | "notice-of-sale" | "on-market" | "out-of-state-absentee-owner" | "out-of-state-owner" | "owner-occupied" | "pending-listing" | "preforeclosure" | "recently-sold" | "same-property-and-mailing-address" | "tax-default" | "tired-landlord" | "unknown-equity" | "vacant" | "vacant-lot";
+/**
+ * QuickList value that can be prefixed with "not-" to exclude
+ */
+export type QuickListValueWithNot = QuickListValue | `not-${QuickListValue}`;
+/**
+ * Complete search criteria object
+ */
+export interface SearchCriteria {
+    query: string;
+    quickList?: QuickListValueWithNot;
+    quickLists?: QuickListValueWithNot[];
+    orQuickLists?: QuickListValueWithNot[];
+    address?: AddressSearchCriteria;
+    assessment?: AssessmentSearchCriteria;
+    building?: BuildingSearchCriteria;
+    compAddress?: CompAddressSearchCriteria;
+    demographics?: DemographicsSearchCriteria;
+    foreclosure?: ForeclosureSearchCriteria;
+    general?: GeneralSearchCriteria;
+    ids?: IdsSearchCriteria;
+    intel?: IntelSearchCriteria;
+    involuntaryLien?: InvoluntaryLienSearchCriteria;
+    legal?: LegalSearchCriteria;
+    listing?: ListingSearchCriteria;
+    lot?: LotSearchCriteria;
+    openLien?: OpenLienSearchCriteria;
+    owner?: OwnerSearchCriteria;
+    permit?: PermitSearchCriteria;
+    propertyOwnerProfile?: PropertyOwnerProfileSearchCriteria;
+    sale?: SaleSearchCriteria;
+    tax?: TaxSearchCriteria;
+    valuation?: ValuationSearchCriteria;
+    or?: OrSearchCriteria[];
+}
+/**
+ * Delivery configuration for webhook or Kinesis
+ */
+export interface DeliveryConfig {
+    type: "webhook" | "kinesis";
+    streamName?: string;
+    region?: string;
+    iamAccessKeyId?: string;
+    iamSecretAccessKey?: string;
+    url?: string;
+    errorUrl?: string;
+    headers?: Record<string, string>;
+}
+/**
+ * Property subscription request payload
+ */
+export interface PropertySubscriptionRequest {
+    searchCriteria: SearchCriteria;
+    deliveryConfig: DeliveryConfig;
+}
+/**
+ * Property subscription response
+ */
+export interface PropertySubscriptionResponse {
+    id: string;
+    status: string;
+}
+/**
+ * Property subscription detail (returned by GET endpoints)
+ */
+export interface PropertySubscriptionDetail {
+    id?: string;
+    searchCriteria?: SearchCriteria;
+    deliveryConfig?: DeliveryConfig;
+    status?: string;
+}
+/**
+ * Get property subscriptions response (returns array directly)
+ */
+export type GetPropertySubscriptionsResponse = PropertySubscriptionDetail[];
+/**
+ * Get property subscription detail response
+ */
+export interface GetPropertySubscriptionDetailResponse {
+    status?: ResponseStatus;
+    results?: {
+        subscription?: PropertySubscriptionDetail;
+        meta?: ResponseMetadata;
+    };
+}
+/**
+ * Delete property subscription response
+ */
+export interface DeletePropertySubscriptionResponse {
+    status?: ResponseStatus;
+}
+/**
+ * Property permit request
+ */
+export interface PropertyPermitRequest {
+    request: {
+        address?: PropertyLookupRequestAddress;
+        hash?: string;
+        propertyId?: string;
+        apn?: string;
+        countyFipsCode?: string;
+        allTags?: StringFilter;
+        description?: StringFilter;
+        endDate?: DateRangeFilter;
+        fileDate?: DateRangeFilter;
+        finalDate?: DateRangeFilter;
+        issueDate?: DateRangeFilter;
+        jobValue?: NumericRangeFilter;
+        startDate?: DateRangeFilter;
+        status?: StringFilter;
+        subType?: StringFilter;
+        type?: StringFilter;
+    };
+    options?: {
+        skip?: number;
+        take?: number;
+        sessionId?: string;
+        dateFormat?: string;
+        showRequests?: boolean;
+        showOptions?: boolean;
+        showMeta?: boolean;
+        sort?: {
+            field?: string;
+            order?: "asc" | "desc";
+        };
+    };
+}
+/**
+ * Property permit details
+ */
+export interface PropertyPermitDetails {
+    permitNumber?: string;
+    type?: string;
+    subtype?: string;
+    description?: string;
+    status?: string;
+    issueDate?: string;
+    finalDate?: string;
+    fileDate?: string;
+    startDate?: string;
+    endDate?: string;
+    jobValue?: number;
+    fees?: number;
+    jurisdiction?: string;
+    applicant?: Record<string, any>;
+    allTags?: string[];
+    tags?: Record<string, boolean>;
+    approvalDuration?: number;
+    constructionDuration?: number;
+    totalDuration?: number;
+}
+/**
+ * Property permit API response
+ */
+export interface PropertyPermitResponse {
+    status?: ResponseStatus;
+    result?: {
+        permits?: PropertyPermitDetails[];
+        property?: {
+            address?: PropertyAddress;
+            id?: string;
+            apn?: string;
+            countyFipsCode?: string;
+        };
+        request?: PropertyPermitRequest["request"];
+        options?: PropertyPermitRequest["options"];
+        meta?: {
+            /** Metadata about the results */
+            results?: ResultsMetadata;
+            apiVersion?: string;
+            requestId?: string;
+        };
+    };
+}
+/**
+ * Property skip trace v3 request item
+ */
+export interface PropertySkipTraceV3RequestItem {
+    name?: {
+        first?: string;
+        last?: string;
+    };
+    propertyAddress?: PropertyLookupRequestAddress;
+    mailingAddress?: PropertyLookupRequestAddress;
+    apn?: string;
+    countyFipsCode?: string;
+    county?: string;
+    state?: string;
+    requestId?: string;
+}
+/**
+ * Property skip trace v3 options
+ */
+export interface PropertySkipTraceV3Options {
+    includeTCPABlacklistedPhones?: boolean;
+    webhookUrl?: string;
+    errorWebhookUrl?: string;
+    dateFormat?: string;
+}
+/**
+ * Property skip trace v3 request
+ */
+export interface PropertySkipTraceV3Request {
+    requests: PropertySkipTraceV3RequestItem[];
+    options?: PropertySkipTraceV3Options;
+}
+/**
+ * Property skip trace v3 person
+ */
+export interface PropertySkipTraceV3Person {
+    propertyOwner?: boolean;
+    name?: {
+        first?: string;
+        last?: string;
+        middle?: string;
+        full?: string;
+    };
+    addresses?: Array<{
+        hash?: string;
+        addressValidity?: string;
+        fullAddress?: string;
+        street?: string;
+        city?: string;
+        county?: string;
+        state?: string;
+        zip?: string;
+        zipPlus4?: string;
+        rank?: number;
+        propertyMailingAddress?: boolean;
+    }>;
+    phones?: Array<{
+        rank?: number;
+        number?: string;
+        type?: string;
+        carrier?: string;
+        tested?: boolean;
+        reachable?: boolean;
+        dnc?: boolean;
+        tcpa?: boolean;
+    }>;
+    emails?: Array<{
+        rank?: number;
+        email?: string;
+        tested?: boolean;
+    }>;
+    litigator?: boolean;
+    deceased?: boolean;
+    dob?: string;
+}
+/**
+ * Property skip trace v3 result item
+ */
+export interface PropertySkipTraceV3ResultItem {
+    inputIndex?: number;
+    input?: {
+        propertyAddress?: PropertyAddress;
+        requestId?: string;
+        inputIndex?: number;
+        inputId?: string;
+        name?: {
+            first?: string;
+            last?: string;
+        };
+        mailingAddress?: PropertyAddress;
+        apn?: string;
+        countyFipsCode?: string;
+        county?: string;
+        state?: string;
+    };
+    property?: {
+        id?: string;
+        address?: PropertyAddress;
+        mailingAddress?: PropertyAddress;
+        owners?: Array<{
+            name?: {
+                first?: string;
+                middle?: string;
+                last?: string;
+                full?: string;
+            };
+        }>;
+    };
+    persons?: PropertySkipTraceV3Person[];
+    meta?: {
+        matched?: boolean;
+        error?: boolean;
+    };
+}
+/**
+ * Property skip trace v3 API response
+ */
+export interface PropertySkipTraceV3Response {
+    status?: ResponseStatus;
+    result?: {
+        data?: PropertySkipTraceV3ResultItem[];
+        options?: PropertySkipTraceV3Options;
+        meta?: {
+            apiVersion?: string;
+            performance?: PerformanceMetrics;
+            results?: {
+                requestCount?: number;
+                matchCount?: number;
+                noMatchCount?: number;
+                errorCount?: number;
+            };
+            requestId?: string;
+        };
+    };
+}
+/**
+ * Property skip trace v3 async request
+ */
+export interface PropertySkipTraceV3AsyncRequest {
+    requests: PropertySkipTraceV3RequestItem[];
+    options?: PropertySkipTraceV3Options;
+}
+/**
+ * Property skip trace v3 async API response
+ */
+export interface PropertySkipTraceV3AsyncResponse {
+    status?: ResponseStatus;
+    result?: {
+        requestId?: string;
+        webhookUrl?: string;
+        errorWebhookUrl?: string;
+        meta?: {
+            apiVersion?: string;
+            performance?: PerformanceMetrics;
+        };
+    };
+}
+/**
+ * Property search preview/estimate response
+ * Used to preview how many properties match search criteria before creating a subscription
+ */
+export interface PropertySearchPreviewResponse {
+    /**
+     * Estimated or exact count of properties matching the search criteria
+     */
+    count?: number;
+    /**
+     * Estimated count (may be approximate)
+     */
+    estimatedCount?: number;
+    /**
+     * Exact count (if available)
+     */
+    exactCount?: number;
+    /**
+     * Whether the count is an estimate or exact
+     */
+    isEstimate?: boolean;
+    /**
+     * Sample properties (if returned)
+     */
+    sampleProperties?: Property[];
+    /**
+     * Additional metadata about the search
+     */
+    metadata?: {
+        query?: string;
+        searchCriteria?: Partial<SearchCriteria>;
+    };
+}
+/**
+ * Property address information
+ */
+export interface PropertyAddress {
+    addressValidity?: string;
+    houseNumber?: string;
+    street?: string;
+    city?: string;
+    county?: string;
+    state?: string;
+    zip?: string;
+    zipPlus4?: string;
+    latitude?: number;
+    longitude?: number;
+    countyFipsCode?: string;
+    hash?: string;
+}
+/**
+ * Mailing address information
+ */
+export interface MailingAddress {
+    street?: string;
+    city?: string;
+    state?: string;
+    zip?: string;
+    hash?: string;
+    addressValidity?: string;
+    county?: string;
+    zipPlus4?: string;
+    deliveryPointCode?: string;
+    dpvMatchCode?: string;
+    dpvFootnotes?: string;
+}
+/**
+ * Deed history entry
+ */
+export interface DeedHistoryEntry {
+    buyers?: string[];
+    sellers?: string[];
+    recordingDate?: string;
+    saleDate?: string;
+    documentNumber?: string;
+    documentTypeCode?: string;
+    documentType?: string;
+    salePrice?: number;
+    transactionType?: string;
+    transactionTypeCode?: string;
+    mailingAddress?: MailingAddress;
+    newConstruction?: boolean;
+    interFamily?: boolean;
+}
+/**
+ * Demographics information
+ */
+export interface Demographics {
+    age?: number;
+    householdSize?: number;
+    income?: number;
+    netWorth?: number;
+    discretionaryIncome?: number;
+    homeownerRenterCode?: string;
+    homeownerRenter?: string;
+    genderCode?: string;
+    gender?: string;
+    maritalStatusCode?: string;
+    maritalStatus?: string;
+    religious?: boolean;
+    religiousAffiliationCode?: string;
+    religiousAffiliation?: string;
+    individualEducationCode?: string;
+    individualEducation?: string;
+    individualOccupation?: string;
+    individualOccupationCode?: string;
+}
+/**
+ * Foreclosure information
+ */
+export interface Foreclosure {
+    statusCode?: string;
+    status?: string;
+    recordingDate?: string;
+    filingDate?: string;
+    documentNumber?: string;
+    documentTypeCode?: string;
+    documentType?: string;
+    releaseDate?: string;
+}
+/**
+ * Property IDs
+ */
+export interface PropertyIds {
+    apn?: string;
+}
+/**
+ * Property images
+ */
+export interface PropertyImages {
+    imageCount?: number;
+    imageUrls?: string[];
+}
+/**
+ * Intel information
+ */
+export interface Intel {
+    salePropensity?: number;
+    salePropensityStatus?: string;
+    salePropensityCategory?: string;
+}
+/**
+ * Tax information entry
+ */
+export interface TaxEntry {
+    amount?: number;
+    year?: number;
+}
+/**
+ * Listing information
+ */
+export interface Listing {
+    status?: string;
+    price?: number;
+    rental?: boolean;
+    originalListingDate?: string;
+    maxListPrice?: number;
+    maxListPriceDate?: string;
+    minListPrice?: number;
+    minListPriceDate?: string;
+    soldPrice?: number;
+    soldDate?: string;
+    failedListingDate?: string;
+    bedroomCount?: number;
+    bathroomCount?: number;
+    totalBuildingAreaSquareFeet?: number;
+    lotSizeSquareFeet?: number;
+    propertyType?: string;
+    yearBuilt?: number;
+    appliances?: string[];
+    roofTypes?: string[];
+    coolingTypes?: string[];
+    heatingTypes?: string[];
+    newConstruction?: boolean;
+    listingUrl?: string;
+    livingArea?: number;
+    taxes?: TaxEntry[];
+    salePriceIsEstimated?: boolean;
+}
+/**
+ * Mortgage history entry
+ */
+export interface MortgageHistoryEntry {
+    borrowers?: string[];
+    saleDate?: string;
+    recordingDate?: string;
+    dueDate?: string;
+    lenderName?: string;
+    loanTypeCode?: string;
+    loanType?: string;
+    loanAmount?: number;
+    loanTermMonths?: number;
+    interestRate?: number;
+    transactionType?: string;
+    transactionTypeCode?: string;
+    documentDate?: string;
+}
+/**
+ * Open lien information
+ */
+export interface OpenLien {
+    totalOpenLienCount?: number;
+}
+/**
+ * Owner name entry
+ */
+export interface OwnerName {
+    last?: string;
+    full?: string;
+}
+/**
+ * Owner information
+ */
+export interface Owner {
+    fullName?: string;
+    mailingAddress?: MailingAddress;
+    names?: OwnerName[];
+}
+/**
+ * Property owner profile
+ */
+export interface PropertyOwnerProfile {
+    averageYearBuilt?: number;
+    propertiesCount?: number;
+    mortgagesTotalBalance?: number;
+    mortgagesCount?: number;
+    mortgagesAverageBalance?: number;
+}
+/**
+ * Quick lists flags
+ */
+export interface QuickLists {
+    absenteeOwner?: boolean;
+    absenteeOwnerInState?: boolean;
+    absenteeOwnerOutOfState?: boolean;
+    activeListing?: boolean;
+    activeAuction?: boolean;
+    cashBuyer?: boolean;
+    corporateOwned?: boolean;
+    expiredListing?: boolean;
+    failedListing?: boolean;
+    freeAndClear?: boolean;
+    fixAndFlip?: boolean;
+    forSaleByOwner?: boolean;
+    highEquity?: boolean;
+    inherited?: boolean;
+    involuntaryLien?: boolean;
+    listedBelowMarketPrice?: boolean;
+    lowEquity?: boolean;
+    mailingAddressVacant?: boolean;
+    onMarket?: boolean;
+    outOfStateOwner?: boolean;
+    ownerOccupied?: boolean;
+    pendingListing?: boolean;
+    preforeclosure?: boolean;
+    recentlySold?: boolean;
+    samePropertyAndMailingAddress?: boolean;
+    seniorOwner?: boolean;
+    taxDefault?: boolean;
+    tiredLandlord?: boolean;
+    unknownEquity?: boolean;
+    vacant?: boolean;
+    vacantLot?: boolean;
+    hasHoa?: boolean;
+    hasHoaFees?: boolean;
+    canceledListing?: boolean;
+    noticeOfSale?: boolean;
+    noticeOfDefault?: boolean;
+    noticeOfLisPendens?: boolean;
+}
+/**
+ * Prior sale mortgage information
+ */
+export interface PriorSaleMortgage {
+    documentNumber?: string;
+    pageNumber?: string | null;
+    bookNumber?: string | null;
+    recordingDate?: string;
+    loanAmount?: number;
+    loanTypeCode?: string;
+    loanType?: string;
+    financingTypeCode?: string | null;
+    financingType?: string | null;
+    interestRate?: number;
+    dueDate?: string;
+    lenderName?: string;
+    loanTerm?: string;
+}
+/**
+ * Sale information
+ */
+export interface Sale {
+    priorSale?: {
+        mortgages?: PriorSaleMortgage[];
+    };
+}
+/**
+ * Valuation information
+ */
+export interface Valuation {
+    estimatedValue?: number;
+    priceRangeMin?: number;
+    priceRangeMax?: number;
+    standardDeviation?: number;
+    confidenceScore?: number;
+    asOfDate?: string;
+    equityCurrentEstimatedBalance?: number;
+    ltv?: number;
+    equityPercent?: number;
+}
+/**
+ * Complete property object from search results
+ */
+export interface Property {
+    _id?: string;
+    address?: PropertyAddress;
+    deedHistory?: DeedHistoryEntry[];
+    demographics?: Demographics;
+    foreclosure?: Foreclosure;
+    ids?: PropertyIds;
+    images?: PropertyImages;
+    intel?: Intel;
+    involuntaryLien?: Record<string, never>;
+    listing?: Listing;
+    mls?: Listing;
+    mortgageHistory?: MortgageHistoryEntry[];
+    openLien?: OpenLien;
+    owner?: Owner;
+    permit?: Record<string, never>;
+    propertyOwnerProfile?: PropertyOwnerProfile;
+    quickLists?: QuickLists;
+    sale?: Sale;
+    valuation?: Valuation;
+}
+/**
+ * Response status information
+ */
+export interface ResponseStatus {
+    code: number;
+    text: string;
+}
+/**
+ * Performance metrics
+ */
+export interface PerformanceMetrics {
+    totalRequestTime?: number;
+    startTime?: string;
+    endTime?: string;
+}
+/**
+ * Results metadata
+ */
+export interface ResultsMetadata {
+    /** Number of results returned. This is the number of properties that matched the search criteria and were returned in the response. */
+    resultCount?: number;
+    /** Number of results found. This is the total number of properties that matched the search criteria. */
+    resultsFound?: number;
+}
+/**
+ * Response metadata
+ */
+export interface ResponseMetadata {
+    apiVersion?: string;
+    performance?: PerformanceMetrics;
+    results?: ResultsMetadata;
+}
+/**
+ * Property search results
+ * Response model for multiple properties
+ */
+export interface PropertySearchResults {
+    /**
+     * An array of objects containing summary information about the property
+     */
+    quicklistCounts?: QuickLists[];
+    /**
+     * An array of objects containing full property details
+     */
+    properties?: Property[];
+    /**
+     * Response model for geocoding polygon responses
+     */
+    areaPolygon?: GeoLocationPolygon;
+    /**
+     * An object containing property search criteria. Multiple search criteria are combined using an AND operation.
+     */
+    searchCriteria?: SearchCriteria;
+    /**
+     * An object containing the request options
+     */
+    options?: PropertyLookupOptions;
+    /**
+     * Metadata describing the entire batch
+     */
+    meta?: ResponseMetadata;
+}
+/**
+ * Property search API response
+ * Response structure from POST /api/v1/property/search
+ *
+ * @see https://developer.batchdata.com/docs/batchdata/batchdata-v1/operations/create-a-property-search
+ */
+export interface PropertySearchResponse {
+    status?: ResponseStatus;
+    results?: PropertySearchResults;
+}
+/**
+ * Address verification request item
+ */
+export interface AddressVerifyRequestItem {
+    street: string;
+    city: string;
+    state: string;
+    zip?: string;
+    requestId?: string | null;
+}
+/**
+ * Address verification request options
+ */
+export interface AddressVerifyOptions {
+    showRequests?: boolean;
+}
+/**
+ * Address verification request
+ */
+export interface AddressVerifyRequest {
+    requests: AddressVerifyRequestItem[];
+    options?: AddressVerifyOptions;
+}
+/**
+ * Verified address metadata
+ */
+export interface VerifiedAddressMeta {
+    error?: boolean;
+    normalized?: boolean;
+    hashed?: boolean;
+}
+/**
+ * Verified address result
+ */
+export interface VerifiedAddress {
+    oldHashes?: string[];
+    street?: string;
+    city?: string;
+    cityAlias?: string | null;
+    state?: string;
+    zip?: string;
+    county?: string;
+    hash?: string;
+    latitude?: number;
+    longitude?: number;
+    geoLocation?: [number, number];
+    requestId?: number | string;
+    formattedStreet?: string;
+    streetNoUnit?: string;
+    meta?: VerifiedAddressMeta;
+    houseNumber?: string;
+    zipPlus4?: string;
+    vacant?: string;
+    countyFipsCode?: string;
+    carrierRoute?: string;
+    congressionalDistrict?: string;
+    timeZone?: string;
+    utcOffset?: number;
+    daylightSavingsTime?: boolean;
+    dpvMatchCode?: string;
+    dpvFootnotes?: string;
+    footnotes?: string;
+}
+/**
+ * Address verification results metadata
+ */
+export interface AddressVerifyResultsMeta {
+    requestCount?: number;
+    normalizedCount?: number;
+    notNormalizedCount?: number;
+    hashedCount?: number;
+    notHashedCount?: number;
+    errorCount?: number;
+}
+/**
+ * Address verification response results
+ */
+export interface AddressVerifyResults {
+    addresses: VerifiedAddress[];
+    meta?: {
+        apiVersion?: string;
+        results?: AddressVerifyResultsMeta;
+        performance?: PerformanceMetrics;
+        requestId?: string;
+    };
+}
+/**
+ * Address verification API response
+ */
+export interface AddressVerifyResponse {
+    status?: ResponseStatus;
+    results?: AddressVerifyResults;
+}
+/**
+ * Address autocomplete search criteria
+ */
+export interface AddressAutocompleteSearchCriteria {
+    query: string;
+    location?: {
+        mode?: string;
+    };
+}
+/**
+ * Address autocomplete options
+ */
+export interface AddressAutocompleteOptions {
+    skip?: number;
+    take?: number;
+    suggestionTypes?: string[];
+    uspsVerifiedAddresses?: boolean;
+}
+/**
+ * Address autocomplete request
+ */
+export interface AddressAutocompleteRequest {
+    searchCriteria: AddressAutocompleteSearchCriteria;
+    options?: AddressAutocompleteOptions;
+}
+/**
+ * Address autocomplete suggestion
+ */
+export interface AddressAutocompleteSuggestion {
+    text?: string;
+    address?: string;
+    city?: string;
+    state?: string;
+    zip?: string;
+    country?: string;
+}
+/**
+ * Address autocomplete API response
+ */
+export interface AddressAutocompleteResponse {
+    status?: ResponseStatus;
+    result?: {
+        suggestions?: AddressAutocompleteSuggestion[];
+        options?: AddressAutocompleteOptions;
+        meta?: {
+            apiVersion?: string;
+            performance?: PerformanceMetrics;
+            results?: ResultsMetadata;
+            requestId?: string;
+        };
+    };
+}
+/**
+ * Address geocode request item
+ */
+export interface AddressGeocodeRequestItem {
+    address: string;
+    requestId?: string;
+}
+/**
+ * Address geocode options
+ */
+export interface AddressGeocodeOptions {
+    showRequests?: boolean;
+}
+/**
+ * Address geocode request
+ */
+export interface AddressGeocodeRequest {
+    requests: AddressGeocodeRequestItem[];
+    options?: AddressGeocodeOptions;
+}
+/**
+ * Geocoded address result
+ */
+export interface GeocodedAddress {
+    latitude?: number;
+    longitude?: number;
+    geoLocation?: [number, number];
+    formattedAddress?: string;
+    street?: string;
+    city?: string;
+    state?: string;
+    zip?: string;
+    country?: string;
+    accuracy?: string;
+}
+/**
+ * Address geocode API response
+ */
+export interface AddressGeocodeResponse {
+    status?: ResponseStatus;
+    result?: {
+        addresses?: GeocodedAddress[];
+        meta?: {
+            apiVersion?: string;
+            performance?: PerformanceMetrics;
+            requestCount?: number;
+            matchCount?: number;
+            errorCount?: number;
+            noMatchCount?: number;
+            requestId?: string;
+        };
+    };
+}
+/**
+ * Address reverse geocode request location
+ */
+export interface AddressReverseGeocodeRequestLocation {
+    latitude: number;
+    longitude: number;
+}
+/**
+ * Address reverse geocode options
+ */
+export interface AddressReverseGeocodeOptions {
+    showPropertyOnly?: boolean;
+    showRequests?: boolean;
+}
+/**
+ * Address reverse geocode request
+ */
+export interface AddressReverseGeocodeRequest {
+    request: AddressReverseGeocodeRequestLocation;
+    options?: AddressReverseGeocodeOptions;
+}
+/**
+ * Reverse geocoded address components
+ */
+export interface ReverseGeocodedComponents {
+    street?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+    postal_code?: string;
+    county?: string;
+}
+/**
+ * Reverse geocoded address result
+ */
+export interface ReverseGeocodedAddress {
+    street?: string;
+    city?: string;
+    state?: string;
+    zip?: string;
+    streetNoUnit?: string;
+    formattedStreet?: string;
+    latitude?: number;
+    longitude?: number;
+    geoLocation?: [number, number];
+    types?: string[];
+    meta?: {
+        error?: boolean;
+    };
+    geoStatus?: string | null;
+    address?: string;
+    components?: ReverseGeocodedComponents;
+}
+/**
+ * Address reverse geocode API response
+ */
+export interface AddressReverseGeocodeResponse {
+    status?: ResponseStatus;
+    result?: {
+        addresses?: ReverseGeocodedAddress[];
+        meta?: {
+            apiVersion?: string;
+            performance?: PerformanceMetrics;
+            requestId?: string;
+        };
+        addressMeta?: {
+            error?: boolean;
+        };
+        request?: AddressReverseGeocodeRequestLocation;
+    };
+}
+/**
+ * Property lookup request item address
+ */
+export interface PropertyLookupRequestAddress {
+    street?: string;
+    city?: string;
+    state?: string;
+    zip?: string;
+    county?: string;
+}
+/**
+ * Property lookup request item
+ */
+export interface PropertyLookupRequestItem {
+    address?: PropertyLookupRequestAddress;
+    propertyId?: string;
+    hash?: string;
+    apn?: string;
+    countyFipsCode?: string;
+    requestId?: string;
+}
+/**
+ * Property lookup options (shared with property search)
+ */
+export interface PropertyLookupOptions {
+    skip?: number;
+    take?: number;
+    showRequests?: boolean;
+    areaPolygon?: boolean;
+    quicklistCounts?: boolean;
+    useDistance?: boolean;
+    useBoundingBox?: boolean;
+    distanceMiles?: number;
+    distanceYards?: number;
+    distanceFeet?: number;
+    distanceKilometers?: number;
+    distanceMeters?: number;
+    useBedrooms?: boolean;
+    minBedrooms?: number;
+    maxBedrooms?: number;
+    boundingBoxNw?: GeoPoint;
+    boundingBoxSe?: GeoPoint;
+    useBathrooms?: boolean;
+    minBathrooms?: number;
+    maxBathrooms?: number;
+    useStories?: boolean;
+    minStories?: number;
+    maxStories?: number;
+    useArea?: boolean;
+    minAreaPercent?: number;
+    maxAreaPercent?: number;
+    useYearBuilt?: boolean;
+    minYearBuilt?: number;
+    maxYearBuilt?: number;
+    useLotSize?: boolean;
+    minLotSizePercent?: number;
+    maxLotSizePercent?: number;
+    webhookUrl?: string;
+    errorWebhookUrl?: string;
+    skipTrace?: boolean;
+    aggregateLoanTypes?: boolean;
+    images?: boolean;
+    dateFormat?: string;
+    sort?: {
+        field?: string;
+        order?: "asc" | "desc" | "random";
+        sessionId?: string;
+    };
+    useSubdivision?: boolean;
+}
+/**
+ * Property search request (synchronous)
+ */
+export interface PropertySearchRequest {
+    searchCriteria: SearchCriteria;
+    options?: PropertyLookupOptions;
+}
+/**
+ * Property lookup request
+ */
+export interface PropertyLookupRequest {
+    requests: PropertyLookupRequestItem[];
+    options?: PropertyLookupOptions;
+}
+/**
+ * Property lookup API response (same structure as PropertySearchResponse)
+ */
+export interface PropertyLookupResponse {
+    status?: ResponseStatus;
+    results?: {
+        properties?: Property[];
+        meta?: ResponseMetadata;
+    };
+}
+/**
+ * Property lookup async request
+ */
+export interface PropertyLookupAsyncRequest {
+    requests: PropertyLookupRequestItem[];
+    options?: PropertyLookupOptions;
+}
+/**
+ * Property lookup async API response
+ * Async endpoints return only a status object. Full results are delivered to the webhook URL.
+ */
+export interface PropertyLookupAsyncResponse {
+    status?: ResponseStatus;
+}
+/**
+ * Property lookup async webhook payload
+ * The webhook payload for PropertyLookupAsync matches the synchronous PropertyLookupResponse format.
+ */
+export type PropertyLookupAsyncWebhookPayload = PropertyLookupResponse;
+/**
+ * Property search async request
+ */
+export interface PropertySearchAsyncRequest {
+    searchCriteria: SearchCriteria;
+    options?: PropertyLookupOptions;
+}
+/**
+ * Property search async API response
+ * Async endpoints return only a status object. Full results are delivered to the webhook URL.
+ */
+export interface PropertySearchAsyncResponse {
+    status?: ResponseStatus;
+}
+/**
+ * Property search async webhook payload
+ * The webhook payload for PropertySearchAsync matches the synchronous PropertySearchResponse format.
+ */
+export type PropertySearchAsyncWebhookPayload = PropertySearchResponse;
+/**
+ * Property skip trace request item
+ */
+export interface PropertySkipTraceRequestItem {
+    propertyAddress?: PropertyLookupRequestAddress;
+    mailingAddress?: PropertyLookupRequestAddress;
+    name?: {
+        first?: string;
+        last?: string;
+    };
+    apn?: string;
+    countyFipsCode?: string;
+    county?: string;
+    state?: string;
+    requestId?: string;
+}
+/**
+ * Property skip trace request
+ */
+export interface PropertySkipTraceRequest {
+    requests: PropertySkipTraceRequestItem[];
+    options?: {
+        skip?: number;
+        take?: number;
+        showRequests?: boolean;
+        webhookUrl?: string;
+        errorWebhookUrl?: string;
+    };
+}
+/**
+ * Property skip trace API response
+ */
+export interface PropertySkipTraceResponse {
+    status?: ResponseStatus;
+    results?: {
+        properties?: Property[];
+        meta?: ResponseMetadata;
+    };
+}
+/**
+ * Property skip trace async request
+ */
+export interface PropertySkipTraceAsyncRequest {
+    requests: PropertySkipTraceRequestItem[];
+    options?: {
+        skip?: number;
+        take?: number;
+        showRequests?: boolean;
+        webhookUrl?: string;
+        errorWebhookUrl?: string;
+    };
+}
+/**
+ * Property skip trace async API response
+ * Async endpoints return only a status object. Full results are delivered to the webhook URL.
+ */
+export interface PropertySkipTraceAsyncResponse {
+    status?: ResponseStatus;
+}
+/**
+ * Property skip trace async webhook payload
+ * The webhook payload for PropertySkipTraceAsync matches the synchronous PropertySkipTraceResponse format.
+ */
+export type PropertySkipTraceAsyncWebhookPayload = PropertySkipTraceResponse;
+/**
+ * Phone verification request
+ * The requests array is a list of phone numbers (strings) for which you want verification information.
+ */
+export interface PhoneVerificationRequest {
+    requests: string[];
+    options?: {
+        showRequests?: boolean;
+    };
+}
+/**
+ * Phone verification result
+ */
+export interface PhoneVerificationResult {
+    phone?: string;
+    isValid?: boolean;
+    phoneType?: string;
+    carrier?: string;
+    lineType?: string;
+    countryCode?: string;
+    areaCode?: string;
+    requestId?: string | number;
+}
+/**
+ * Phone verification API response
+ */
+export interface PhoneVerificationResponse {
+    status?: ResponseStatus;
+    results?: {
+        phoneNumbers?: PhoneVerificationResult[];
+        meta?: {
+            apiVersion?: string;
+            performance?: PerformanceMetrics;
+            requestCount?: number;
+            matchCount?: number;
+            errorCount?: number;
+            requestId?: string;
+        };
+    };
+}
+/**
+ * Phone verification async request
+ * The requests array is a list of phone numbers (strings) for which you want verification information.
+ */
+export interface PhoneVerificationAsyncRequest {
+    requests: string[];
+    options?: {
+        showRequests?: boolean;
+        webhookUrl?: string;
+        errorWebhookUrl?: string;
+    };
+}
+/**
+ * Phone verification async API response
+ * Async endpoints return only a status object. Full results are delivered to the webhook URL.
+ */
+export interface PhoneVerificationAsyncResponse {
+    status?: ResponseStatus;
+}
+/**
+ * Phone verification async webhook payload
+ * The webhook payload for PhoneVerificationAsync matches the synchronous PhoneVerificationResponse format.
+ */
+export type PhoneVerificationAsyncWebhookPayload = PhoneVerificationResponse;
+/**
+ * Phone DNC (Do Not Call) request
+ * The requests array is a list of phone numbers (strings) for which you want DNC information.
+ */
+export interface PhoneDNCRequest {
+    requests: string[];
+    options?: {
+        showRequests?: boolean;
+    };
+}
+/**
+ * Phone DNC result
+ */
+export interface PhoneDNCResult {
+    number?: string;
+    dnc?: boolean;
+    meta?: {
+        error?: boolean;
+        matched?: boolean;
+    };
+}
+/**
+ * Phone DNC API response
+ */
+export interface PhoneDNCResponse {
+    status?: ResponseStatus;
+    results?: {
+        phoneNumbers?: PhoneDNCResult[];
+        meta?: {
+            apiVersion?: string;
+            performance?: PerformanceMetrics;
+            requestCount?: number;
+            matchCount?: number;
+            errorCount?: number;
+            requestId?: string;
+        };
+    };
+}
+/**
+ * Phone DNC async request
+ * The requests array is a list of phone numbers (strings) for which you want DNC information.
+ */
+export interface PhoneDNCAsyncRequest {
+    requests: string[];
+    options?: {
+        showRequests?: boolean;
+        webhookUrl?: string;
+        errorWebhookUrl?: string;
+    };
+}
+/**
+ * Phone DNC async API response
+ * Async endpoints return only a status object. Full results are delivered to the webhook URL.
+ */
+export interface PhoneDNCAsyncResponse {
+    status?: ResponseStatus;
+}
+/**
+ * Phone DNC async webhook payload
+ * The webhook payload for PhoneDNCAsync matches the synchronous PhoneDNCResponse format.
+ */
+export type PhoneDNCAsyncWebhookPayload = PhoneDNCResponse;
+/**
+ * Phone TCPA (Telephone Consumer Protection Act) request
+ * The requests array is a list of phone numbers (strings) for which you want TCPA information.
+ */
+export interface PhoneTCPARequest {
+    requests: string[];
+    options?: {
+        showRequests?: boolean;
+    };
+}
+/**
+ * Phone TCPA result
+ */
+export interface PhoneTCPAResult {
+    number?: string;
+    tcpa?: boolean;
+    meta?: {
+        error?: boolean;
+        matched?: boolean;
+    };
+}
+/**
+ * Phone TCPA API response
+ */
+export interface PhoneTCPAResponse {
+    status?: ResponseStatus;
+    results?: {
+        phoneNumbers?: PhoneTCPAResult[];
+        meta?: {
+            apiVersion?: string;
+            performance?: PerformanceMetrics;
+            requestCount?: number;
+            matchCount?: number;
+            errorCount?: number;
+            requestId?: string;
+        };
+    };
+}
+/**
+ * Phone TCPA async request
+ * The requests array is a list of phone numbers (strings) for which you want TCPA information.
+ */
+export interface PhoneTCPAAsyncRequest {
+    requests: string[];
+    options?: {
+        showRequests?: boolean;
+        webhookUrl?: string;
+        errorWebhookUrl?: string;
+    };
+}
+/**
+ * Phone TCPA async API response
+ */
+/**
+ * Phone TCPA async API response
+ * Async endpoints return only a status object. Full results are delivered to the webhook URL.
+ */
+export interface PhoneTCPAAsyncResponse {
+    status?: ResponseStatus;
+}
+/**
+ * Phone TCPA async webhook payload
+ * The webhook payload for PhoneTCPAAsync matches the synchronous PhoneTCPAResponse format.
+ */
+export type PhoneTCPAAsyncWebhookPayload = PhoneTCPAResponse;