@land-catalyst/batch-data-sdk 1.1.12

package/dist/builders.js

@@ -0,0 +1,2622 @@
+"use strict";
+/**
+ * BatchData.io Query Builders
+ *
+ * Fluent query builder API for constructing BatchData property subscription requests
+ *
+ * Usage example:
+ * ```typescript
+ * const searchQuery = new SearchCriteriaBuilder("Maricopa County, AZ")
+ *   .address(new AddressSearchCriteriaBuilder()
+ *     .city(new StringFilterBuilder().equals("Phoenix").build())
+ *     .state(new StringFilterBuilder().equals("AZ").build())
+ *     .build())
+ *   .building(new BuildingSearchCriteriaBuilder()
+ *     .yearBuilt(new NumericRangeFilterBuilder().min(1990).max(2020).build())
+ *     .build())
+ *   .build();
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyPermitRequestBuilder = exports.PropertyLookupAsyncRequestBuilder = exports.PropertySearchAsyncRequestBuilder = exports.PropertySearchRequestBuilder = exports.PropertyLookupRequestBuilder = exports.AsyncPropertyLookupOptionsBuilder = exports.PropertyLookupOptionsBuilder = exports.PropertyLookupRequestItemBuilder = exports.PropertySubscriptionBuilder = exports.DeliveryConfigBuilder = exports.SearchCriteriaBuilder = exports.OrSearchCriteriaBuilder = exports.ValuationSearchCriteriaBuilder = exports.TaxSearchCriteriaBuilder = exports.SaleSearchCriteriaBuilder = exports.PropertyOwnerProfileSearchCriteriaBuilder = exports.PermitSearchCriteriaBuilder = exports.OwnerSearchCriteriaBuilder = exports.OpenLienSearchCriteriaBuilder = exports.LotSearchCriteriaBuilder = exports.ListingSearchCriteriaBuilder = exports.LegalSearchCriteriaBuilder = exports.InvoluntaryLienSearchCriteriaBuilder = exports.IntelSearchCriteriaBuilder = exports.IdsSearchCriteriaBuilder = exports.GeneralSearchCriteriaBuilder = exports.ForeclosureSearchCriteriaBuilder = exports.DemographicsSearchCriteriaBuilder = exports.CompAddressSearchCriteriaBuilder = exports.BuildingSearchCriteriaBuilder = exports.AssessmentSearchCriteriaBuilder = exports.AddressSearchCriteriaBuilder = exports.GeoLocationFactory = exports.DateRangeFilterBuilder = exports.NumericRangeFilterBuilder = exports.StringFilterBuilder = void 0;
+/**
+ * Abstract base class for builders that store nested builders
+ * Handles the common pattern of storing builder instances and building them all at once
+ */
+class BaseBuilder {
+    constructor() {
+        this.criteria = {};
+        this.builders = {};
+    }
+    /**
+     * Helper method to set a property either directly or via a builder configurator.
+     * This extracts the common pattern of checking if a configurator function is provided,
+     * creating/reusing a builder instance, and either calling the configurator or setting
+     * the value directly.
+     *
+     * @param key - The property key to set
+     * @param valueOrConfigurator - Either the direct value or a configurator function
+     * @param builderFactory - Factory function to create a new builder instance if needed
+     * @returns This builder instance for method chaining
+     */
+    setPropertyWithBuilder(key, valueOrConfigurator, builderFactory) {
+        if (typeof valueOrConfigurator === "function") {
+            if (!this.builders[key]) {
+                this.builders[key] = builderFactory();
+            }
+            // Type assertion needed because TypeScript can't narrow the union type properly
+            valueOrConfigurator(this.builders[key]);
+        }
+        else {
+            this.criteria[key] = valueOrConfigurator;
+            this.builders[key] = undefined;
+        }
+        return this;
+    }
+    /**
+     * Helper method that accepts a builder class constructor and infers types from it.
+     * This allows you to pass the builder class directly instead of a factory function.
+     *
+     * @param key - The property key to set
+     * @param valueOrConfigurator - Either the direct value or a configurator function
+     * @param BuilderClass - The builder class constructor (e.g., NumericRangeFilterBuilder)
+     * @returns This builder instance for method chaining
+     */
+    setPropertyWithBuilderClass(key, valueOrConfigurator, BuilderClass) {
+        return this.setPropertyWithBuilder(key, valueOrConfigurator, () => new BuilderClass());
+    }
+    build() {
+        const result = { ...this.criteria };
+        for (const key in this.builders) {
+            const builder = this.builders[key];
+            if (builder) {
+                result[key] = builder.build();
+            }
+        }
+        return result;
+    }
+}
+/**
+ * Base builder for string filters
+ */
+class StringFilterBuilder {
+    constructor() {
+        this.filter = {};
+    }
+    static from(filter) {
+        const builder = new StringFilterBuilder();
+        builder.filter = { ...filter };
+        return builder;
+    }
+    equals(value) {
+        this.filter.equals = value;
+        return this;
+    }
+    contains(value) {
+        this.filter.contains = value;
+        return this;
+    }
+    startsWith(value) {
+        this.filter.startsWith = value;
+        return this;
+    }
+    endsWith(value) {
+        this.filter.endsWith = value;
+        return this;
+    }
+    inList(values) {
+        this.filter.inList = values;
+        return this;
+    }
+    notInList(values) {
+        this.filter.notInList = values;
+        return this;
+    }
+    matches(patterns) {
+        this.filter.matches = patterns;
+        return this;
+    }
+    build() {
+        return this.filter;
+    }
+}
+exports.StringFilterBuilder = StringFilterBuilder;
+/**
+ * Base builder for numeric range filters
+ */
+class NumericRangeFilterBuilder {
+    constructor() {
+        this.filter = {};
+    }
+    static from(filter) {
+        const builder = new NumericRangeFilterBuilder();
+        builder.filter = { ...filter };
+        return builder;
+    }
+    min(value) {
+        this.filter.min = value;
+        return this;
+    }
+    max(value) {
+        this.filter.max = value;
+        return this;
+    }
+    range(min, max) {
+        this.filter.min = min;
+        this.filter.max = max;
+        return this;
+    }
+    build() {
+        return this.filter;
+    }
+}
+exports.NumericRangeFilterBuilder = NumericRangeFilterBuilder;
+/**
+ * Base builder for date range filters
+ */
+class DateRangeFilterBuilder {
+    constructor() {
+        this.filter = {};
+    }
+    static from(filter) {
+        const builder = new DateRangeFilterBuilder();
+        builder.filter = { ...filter };
+        return builder;
+    }
+    minDate(date) {
+        this.filter.minDate = date;
+        return this;
+    }
+    maxDate(date) {
+        this.filter.maxDate = date;
+        return this;
+    }
+    range(minDate, maxDate) {
+        this.filter.minDate = minDate;
+        this.filter.maxDate = maxDate;
+        return this;
+    }
+    build() {
+        return this.filter;
+    }
+}
+exports.DateRangeFilterBuilder = DateRangeFilterBuilder;
+/**
+ * Helper class for creating geographic location filters
+ * This is not a builder in the traditional sense - it's a factory that creates
+ * different geo location objects (distance, bounding box, polygon)
+ */
+class GeoLocationFactory {
+    /**
+     * Create a distance-based filter
+     */
+    static distance(latitude, longitude, options) {
+        const distance = {
+            geoPoint: { latitude, longitude },
+        };
+        if (options?.meters)
+            distance.distanceMeters = options.meters;
+        if (options?.kilometers)
+            distance.distanceKilometers = options.kilometers;
+        if (options?.feet)
+            distance.distanceFeet = options.feet;
+        if (options?.yards)
+            distance.distanceYards = options.yards;
+        if (options?.miles)
+            distance.distanceMiles = options.miles;
+        return distance;
+    }
+    /**
+     * Create a bounding box filter
+     */
+    static boundingBox(nwLatitude, nwLongitude, seLatitude, seLongitude) {
+        return {
+            nwGeoPoint: { latitude: nwLatitude, longitude: nwLongitude },
+            seGeoPoint: { latitude: seLatitude, longitude: seLongitude },
+        };
+    }
+    /**
+     * Create a polygon filter
+     */
+    static polygon(points) {
+        return {
+            geoPoints: points.map((p) => ({
+                latitude: p.latitude,
+                longitude: p.longitude,
+            })),
+        };
+    }
+}
+exports.GeoLocationFactory = GeoLocationFactory;
+/**
+ * Builder for address search criteria
+ */
+class AddressSearchCriteriaBuilder extends BaseBuilder {
+    constructor() {
+        super(...arguments);
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new AddressSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    street(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("street", filterOrConfigurator, StringFilterBuilder);
+    }
+    city(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("city", filterOrConfigurator, StringFilterBuilder);
+    }
+    locality(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("locality", filterOrConfigurator, StringFilterBuilder);
+    }
+    county(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("county", filterOrConfigurator, StringFilterBuilder);
+    }
+    countyFipsCode(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("countyFipsCode", filterOrConfigurator, StringFilterBuilder);
+    }
+    state(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("state", filterOrConfigurator, StringFilterBuilder);
+    }
+    zip(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("zip", filterOrConfigurator, StringFilterBuilder);
+    }
+    unitType(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("unitType", filterOrConfigurator, StringFilterBuilder);
+    }
+    formattedStreet(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("formattedStreet", filterOrConfigurator, StringFilterBuilder);
+    }
+    streetNoUnit(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("streetNoUnit", filterOrConfigurator, StringFilterBuilder);
+    }
+    geoLocationDistance(latitude, longitude, options) {
+        this.criteria.geoLocationDistance = GeoLocationFactory.distance(latitude, longitude, options);
+        return this;
+    }
+    geoLocationBoundingBox(nwLatitude, nwLongitude, seLatitude, seLongitude) {
+        this.criteria.geoLocationBoundingBox = GeoLocationFactory.boundingBox(nwLatitude, nwLongitude, seLatitude, seLongitude);
+        return this;
+    }
+    geoLocationPolygon(points) {
+        this.criteria.geoLocationPolygon = GeoLocationFactory.polygon(points);
+        return this;
+    }
+    initialGeoStatus(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("initialGeoStatus", filterOrConfigurator, StringFilterBuilder);
+    }
+    geoStatus(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("geoStatus", filterOrConfigurator, StringFilterBuilder);
+    }
+    cityState(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("cityState", filterOrConfigurator, StringFilterBuilder);
+    }
+    countyState(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("countyState", filterOrConfigurator, StringFilterBuilder);
+    }
+}
+exports.AddressSearchCriteriaBuilder = AddressSearchCriteriaBuilder;
+/**
+ * Builder for assessment search criteria
+ */
+class AssessmentSearchCriteriaBuilder extends BaseBuilder {
+    constructor() {
+        super(...arguments);
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new AssessmentSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    assessmentYear(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("assessmentYear", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    totalAssessedValue(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("totalAssessedValue", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    assessedImprovementValue(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("assessedImprovementValue", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    assessedLandValue(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("assessedLandValue", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    marketValueYear(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("marketValueYear", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    landMarketValue(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("landMarketValue", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    improvementMarketValue(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("improvementMarketValue", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    totalMarketValue(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("totalMarketValue", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+}
+exports.AssessmentSearchCriteriaBuilder = AssessmentSearchCriteriaBuilder;
+/**
+ * Builder for building search criteria
+ */
+class BuildingSearchCriteriaBuilder extends BaseBuilder {
+    constructor() {
+        super(...arguments);
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new BuildingSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    airConditioningSource(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("airConditioningSource", filterOrConfigurator, StringFilterBuilder);
+    }
+    basementType(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("basementType", filterOrConfigurator, StringFilterBuilder);
+    }
+    totalBuildingAreaSquareFeet(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("totalBuildingAreaSquareFeet", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    buildingClass(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.buildingClass = builder.build();
+        }
+        else {
+            this.criteria.buildingClass = filterOrConfigurator;
+        }
+        return this;
+    }
+    buildingCondition(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.buildingCondition = builder.build();
+        }
+        else {
+            this.criteria.buildingCondition = filterOrConfigurator;
+        }
+        return this;
+    }
+    buildingQuality(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.buildingQuality = builder.build();
+        }
+        else {
+            this.criteria.buildingQuality = filterOrConfigurator;
+        }
+        return this;
+    }
+    buildingType(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.buildingType = builder.build();
+        }
+        else {
+            this.criteria.buildingType = filterOrConfigurator;
+        }
+        return this;
+    }
+    driveway(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.driveway = builder.build();
+        }
+        else {
+            this.criteria.driveway = filterOrConfigurator;
+        }
+        return this;
+    }
+    exteriorWalls(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.exteriorWalls = builder.build();
+        }
+        else {
+            this.criteria.exteriorWalls = filterOrConfigurator;
+        }
+        return this;
+    }
+    floorCover(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.floorCover = builder.build();
+        }
+        else {
+            this.criteria.floorCover = filterOrConfigurator;
+        }
+        return this;
+    }
+    garageParkingSpaceCount(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("garageParkingSpaceCount", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    garage(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.garage = builder.build();
+        }
+        else {
+            this.criteria.garage = filterOrConfigurator;
+        }
+        return this;
+    }
+    heatSource(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.heatSource = builder.build();
+        }
+        else {
+            this.criteria.heatSource = filterOrConfigurator;
+        }
+        return this;
+    }
+    heatingFuelType(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.heatingFuelType = builder.build();
+        }
+        else {
+            this.criteria.heatingFuelType = filterOrConfigurator;
+        }
+        return this;
+    }
+    interiorWalls(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.interiorWalls = builder.build();
+        }
+        else {
+            this.criteria.interiorWalls = filterOrConfigurator;
+        }
+        return this;
+    }
+    buildingCount(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("buildingCount", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    bathroomCount(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("bathroomCount", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    calculatedBathroomCount(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("calculatedBathroomCount", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    bedroomCount(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("bedroomCount", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    patio(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.patio = builder.build();
+        }
+        else {
+            this.criteria.patio = filterOrConfigurator;
+        }
+        return this;
+    }
+    storyCount(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("storyCount", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    features(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.features = builder.build();
+        }
+        else {
+            this.criteria.features = filterOrConfigurator;
+        }
+        return this;
+    }
+    residentialUnitCount(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("residentialUnitCount", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    pool(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.pool = builder.build();
+        }
+        else {
+            this.criteria.pool = filterOrConfigurator;
+        }
+        return this;
+    }
+    porch(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.porch = builder.build();
+        }
+        else {
+            this.criteria.porch = filterOrConfigurator;
+        }
+        return this;
+    }
+    roofCover(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.roofCover = builder.build();
+        }
+        else {
+            this.criteria.roofCover = filterOrConfigurator;
+        }
+        return this;
+    }
+    roofType(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.roofType = builder.build();
+        }
+        else {
+            this.criteria.roofType = filterOrConfigurator;
+        }
+        return this;
+    }
+    sewer(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.sewer = builder.build();
+        }
+        else {
+            this.criteria.sewer = filterOrConfigurator;
+        }
+        return this;
+    }
+    style(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.style = builder.build();
+        }
+        else {
+            this.criteria.style = filterOrConfigurator;
+        }
+        return this;
+    }
+    roomCount(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("roomCount", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    unitCount(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("unitCount", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    constructionType(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.constructionType = builder.build();
+        }
+        else {
+            this.criteria.constructionType = filterOrConfigurator;
+        }
+        return this;
+    }
+    waterService(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.waterService = builder.build();
+        }
+        else {
+            this.criteria.waterService = filterOrConfigurator;
+        }
+        return this;
+    }
+    yearBuilt(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("yearBuilt", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    build() {
+        const result = { ...this.criteria };
+        if (this.builders.airConditioningSource) {
+            result.airConditioningSource =
+                this.builders.airConditioningSource.build();
+        }
+        if (this.builders.basementType) {
+            result.basementType = this.builders.basementType.build();
+        }
+        if (this.builders.totalBuildingAreaSquareFeet) {
+            result.totalBuildingAreaSquareFeet =
+                this.builders.totalBuildingAreaSquareFeet.build();
+        }
+        if (this.builders.buildingClass) {
+            result.buildingClass = this.builders.buildingClass.build();
+        }
+        if (this.builders.buildingCondition) {
+            result.buildingCondition = this.builders.buildingCondition.build();
+        }
+        if (this.builders.buildingQuality) {
+            result.buildingQuality = this.builders.buildingQuality.build();
+        }
+        if (this.builders.buildingType) {
+            result.buildingType = this.builders.buildingType.build();
+        }
+        if (this.builders.driveway) {
+            result.driveway = this.builders.driveway.build();
+        }
+        if (this.builders.exteriorWalls) {
+            result.exteriorWalls = this.builders.exteriorWalls.build();
+        }
+        if (this.builders.floorCover) {
+            result.floorCover = this.builders.floorCover.build();
+        }
+        if (this.builders.garageParkingSpaceCount) {
+            result.garageParkingSpaceCount =
+                this.builders.garageParkingSpaceCount.build();
+        }
+        if (this.builders.garage) {
+            result.garage = this.builders.garage.build();
+        }
+        if (this.builders.heatSource) {
+            result.heatSource = this.builders.heatSource.build();
+        }
+        if (this.builders.heatingFuelType) {
+            result.heatingFuelType = this.builders.heatingFuelType.build();
+        }
+        if (this.builders.interiorWalls) {
+            result.interiorWalls = this.builders.interiorWalls.build();
+        }
+        if (this.builders.buildingCount) {
+            result.buildingCount = this.builders.buildingCount.build();
+        }
+        if (this.builders.bathroomCount) {
+            result.bathroomCount = this.builders.bathroomCount.build();
+        }
+        if (this.builders.calculatedBathroomCount) {
+            result.calculatedBathroomCount =
+                this.builders.calculatedBathroomCount.build();
+        }
+        if (this.builders.bedroomCount) {
+            result.bedroomCount = this.builders.bedroomCount.build();
+        }
+        if (this.builders.patio) {
+            result.patio = this.builders.patio.build();
+        }
+        if (this.builders.storyCount) {
+            result.storyCount = this.builders.storyCount.build();
+        }
+        if (this.builders.features) {
+            result.features = this.builders.features.build();
+        }
+        if (this.builders.residentialUnitCount) {
+            result.residentialUnitCount = this.builders.residentialUnitCount.build();
+        }
+        if (this.builders.pool) {
+            result.pool = this.builders.pool.build();
+        }
+        if (this.builders.porch) {
+            result.porch = this.builders.porch.build();
+        }
+        if (this.builders.roofCover) {
+            result.roofCover = this.builders.roofCover.build();
+        }
+        if (this.builders.roofType) {
+            result.roofType = this.builders.roofType.build();
+        }
+        if (this.builders.sewer) {
+            result.sewer = this.builders.sewer.build();
+        }
+        if (this.builders.style) {
+            result.style = this.builders.style.build();
+        }
+        if (this.builders.roomCount) {
+            result.roomCount = this.builders.roomCount.build();
+        }
+        if (this.builders.unitCount) {
+            result.unitCount = this.builders.unitCount.build();
+        }
+        if (this.builders.constructionType) {
+            result.constructionType = this.builders.constructionType.build();
+        }
+        if (this.builders.waterService) {
+            result.waterService = this.builders.waterService.build();
+        }
+        if (this.builders.yearBuilt) {
+            result.yearBuilt = this.builders.yearBuilt.build();
+        }
+        return result;
+    }
+}
+exports.BuildingSearchCriteriaBuilder = BuildingSearchCriteriaBuilder;
+/**
+ * Builder for comp address search criteria
+ */
+class CompAddressSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new CompAddressSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    street(value) {
+        this.criteria.street = value;
+        return this;
+    }
+    city(value) {
+        this.criteria.city = value;
+        return this;
+    }
+    state(value) {
+        this.criteria.state = value;
+        return this;
+    }
+    zip(value) {
+        this.criteria.zip = value;
+        return this;
+    }
+    hash(value) {
+        this.criteria.hash = value;
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.CompAddressSearchCriteriaBuilder = CompAddressSearchCriteriaBuilder;
+/**
+ * Builder for demographics search criteria
+ */
+class DemographicsSearchCriteriaBuilder extends BaseBuilder {
+    constructor() {
+        super(...arguments);
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new DemographicsSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    age(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("age", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    householdSize(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("householdSize", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    income(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("income", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    netWorth(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("netWorth", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    discretionaryIncome(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("discretionaryIncome", filterOrConfigurator, NumericRangeFilterBuilder);
+    }
+    homeownerRenter(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("homeownerRenter", filterOrConfigurator, StringFilterBuilder);
+    }
+    businessOwner(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("businessOwner", filterOrConfigurator, StringFilterBuilder);
+    }
+    gender(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("gender", filterOrConfigurator, StringFilterBuilder);
+    }
+    hasChildren(value) {
+        this.criteria.hasChildren = { equals: value };
+        return this;
+    }
+    investments(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("investments", filterOrConfigurator, StringFilterBuilder);
+    }
+    demographics(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("demographics", filterOrConfigurator, StringFilterBuilder);
+    }
+    religiousAffiliation(filterOrConfigurator) {
+        return this.setPropertyWithBuilderClass("religiousAffiliation", filterOrConfigurator, StringFilterBuilder);
+    }
+}
+exports.DemographicsSearchCriteriaBuilder = DemographicsSearchCriteriaBuilder;
+/**
+ * Builder for foreclosure search criteria
+ */
+class ForeclosureSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new ForeclosureSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    status(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.status = builder.build();
+        }
+        else {
+            this.criteria.status = filterOrConfigurator;
+        }
+        return this;
+    }
+    recordingDate(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new DateRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.recordingDate = builder.build();
+        }
+        else {
+            this.criteria.recordingDate = filterOrConfigurator;
+        }
+        return this;
+    }
+    auctionDate(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new DateRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.auctionDate = builder.build();
+        }
+        else {
+            this.criteria.auctionDate = filterOrConfigurator;
+        }
+        return this;
+    }
+    releaseDate(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new DateRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.releaseDate = builder.build();
+        }
+        else {
+            this.criteria.releaseDate = filterOrConfigurator;
+        }
+        return this;
+    }
+    auctionMinimumBidAmount(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new NumericRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.auctionMinimumBidAmount = builder.build();
+        }
+        else {
+            this.criteria.auctionMinimumBidAmount = filterOrConfigurator;
+        }
+        return this;
+    }
+    pastDueAmount(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new NumericRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.pastDueAmount = builder.build();
+        }
+        else {
+            this.criteria.pastDueAmount = filterOrConfigurator;
+        }
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.ForeclosureSearchCriteriaBuilder = ForeclosureSearchCriteriaBuilder;
+/**
+ * Builder for general search criteria
+ */
+class GeneralSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new GeneralSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    propertyTypeCategory(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.propertyTypeCategory = builder.build();
+        }
+        else {
+            this.criteria.propertyTypeCategory = filterOrConfigurator;
+        }
+        return this;
+    }
+    propertyTypeDetail(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.propertyTypeDetail = builder.build();
+        }
+        else {
+            this.criteria.propertyTypeDetail = filterOrConfigurator;
+        }
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.GeneralSearchCriteriaBuilder = GeneralSearchCriteriaBuilder;
+/**
+ * Builder for IDs search criteria
+ */
+class IdsSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new IdsSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    addressHash(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.addressHash = builder.build();
+        }
+        else {
+            this.criteria.addressHash = filterOrConfigurator;
+        }
+        return this;
+    }
+    mailingAddressHash(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.mailingAddressHash = builder.build();
+        }
+        else {
+            this.criteria.mailingAddressHash = filterOrConfigurator;
+        }
+        return this;
+    }
+    fipsCode(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.fipsCode = builder.build();
+        }
+        else {
+            this.criteria.fipsCode = filterOrConfigurator;
+        }
+        return this;
+    }
+    apn(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.apn = builder.build();
+        }
+        else {
+            this.criteria.apn = filterOrConfigurator;
+        }
+        return this;
+    }
+    taxId(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.taxId = builder.build();
+        }
+        else {
+            this.criteria.taxId = filterOrConfigurator;
+        }
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.IdsSearchCriteriaBuilder = IdsSearchCriteriaBuilder;
+/**
+ * Builder for intel search criteria
+ */
+class IntelSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new IntelSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    lastSoldDate(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new DateRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.lastSoldDate = builder.build();
+        }
+        else {
+            this.criteria.lastSoldDate = filterOrConfigurator;
+        }
+        return this;
+    }
+    lastSoldPrice(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new NumericRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.lastSoldPrice = builder.build();
+        }
+        else {
+            this.criteria.lastSoldPrice = filterOrConfigurator;
+        }
+        return this;
+    }
+    salePropensity(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new NumericRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.salePropensity = builder.build();
+        }
+        else {
+            this.criteria.salePropensity = filterOrConfigurator;
+        }
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.IntelSearchCriteriaBuilder = IntelSearchCriteriaBuilder;
+/**
+ * Builder for involuntary lien search criteria
+ */
+class InvoluntaryLienSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new InvoluntaryLienSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    lienType(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.lienType = builder.build();
+        }
+        else {
+            this.criteria.lienType = filterOrConfigurator;
+        }
+        return this;
+    }
+    lienTypeCode(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.lienTypeCode = builder.build();
+        }
+        else {
+            this.criteria.lienTypeCode = filterOrConfigurator;
+        }
+        return this;
+    }
+    documentType(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.documentType = builder.build();
+        }
+        else {
+            this.criteria.documentType = filterOrConfigurator;
+        }
+        return this;
+    }
+    documentTypeCode(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.documentTypeCode = builder.build();
+        }
+        else {
+            this.criteria.documentTypeCode = filterOrConfigurator;
+        }
+        return this;
+    }
+    recordingDate(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new DateRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.recordingDate = builder.build();
+        }
+        else {
+            this.criteria.recordingDate = filterOrConfigurator;
+        }
+        return this;
+    }
+    filingDate(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new DateRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.filingDate = builder.build();
+        }
+        else {
+            this.criteria.filingDate = filterOrConfigurator;
+        }
+        return this;
+    }
+    lienAmount(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new NumericRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.lienAmount = builder.build();
+        }
+        else {
+            this.criteria.lienAmount = filterOrConfigurator;
+        }
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.InvoluntaryLienSearchCriteriaBuilder = InvoluntaryLienSearchCriteriaBuilder;
+/**
+ * Builder for legal search criteria
+ */
+class LegalSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new LegalSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    subdivisionName(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.subdivisionName = builder.build();
+        }
+        else {
+            this.criteria.subdivisionName = filterOrConfigurator;
+        }
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.LegalSearchCriteriaBuilder = LegalSearchCriteriaBuilder;
+/**
+ * Builder for listing search criteria
+ */
+class ListingSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new ListingSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    description(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.description = builder.build();
+        }
+        else {
+            this.criteria.description = filterOrConfigurator;
+        }
+        return this;
+    }
+    price(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new NumericRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.price = builder.build();
+        }
+        else {
+            this.criteria.price = filterOrConfigurator;
+        }
+        return this;
+    }
+    daysOnMarket(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new NumericRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.daysOnMarket = builder.build();
+        }
+        else {
+            this.criteria.daysOnMarket = filterOrConfigurator;
+        }
+        return this;
+    }
+    status(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.status = builder.build();
+        }
+        else {
+            this.criteria.status = filterOrConfigurator;
+        }
+        return this;
+    }
+    statusCategory(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.statusCategory = builder.build();
+        }
+        else {
+            this.criteria.statusCategory = filterOrConfigurator;
+        }
+        return this;
+    }
+    failedListingDate(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new DateRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.failedListingDate = builder.build();
+        }
+        else {
+            this.criteria.failedListingDate = filterOrConfigurator;
+        }
+        return this;
+    }
+    soldDate(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new DateRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.soldDate = builder.build();
+        }
+        else {
+            this.criteria.soldDate = filterOrConfigurator;
+        }
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.ListingSearchCriteriaBuilder = ListingSearchCriteriaBuilder;
+/**
+ * Builder for lot search criteria
+ */
+class LotSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new LotSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    lotSizeAcres(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new NumericRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.lotSizeAcres = builder.build();
+        }
+        else {
+            this.criteria.lotSizeAcres = filterOrConfigurator;
+        }
+        return this;
+    }
+    lotDepthFeet(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new NumericRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.lotDepthFeet = builder.build();
+        }
+        else {
+            this.criteria.lotDepthFeet = filterOrConfigurator;
+        }
+        return this;
+    }
+    lotFrontageFeet(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new NumericRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.lotFrontageFeet = builder.build();
+        }
+        else {
+            this.criteria.lotFrontageFeet = filterOrConfigurator;
+        }
+        return this;
+    }
+    lotSizeSquareFeet(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new NumericRangeFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.lotSizeSquareFeet = builder.build();
+        }
+        else {
+            this.criteria.lotSizeSquareFeet = filterOrConfigurator;
+        }
+        return this;
+    }
+    zoningCode(filterOrConfigurator) {
+        if (typeof filterOrConfigurator === "function") {
+            const builder = new StringFilterBuilder();
+            filterOrConfigurator(builder);
+            this.criteria.zoningCode = builder.build();
+        }
+        else {
+            this.criteria.zoningCode = filterOrConfigurator;
+        }
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.LotSearchCriteriaBuilder = LotSearchCriteriaBuilder;
+/**
+ * Builder for open lien search criteria
+ */
+class OpenLienSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new OpenLienSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    allLoanTypes(filter) {
+        this.criteria.allLoanTypes = filter;
+        return this;
+    }
+    juniorLoanTypes(filter) {
+        this.criteria.juniorLoanTypes = filter;
+        return this;
+    }
+    totalOpenLienCount(filter) {
+        this.criteria.totalOpenLienCount = filter;
+        return this;
+    }
+    totalOpenLienBalance(filter) {
+        this.criteria.totalOpenLienBalance = filter;
+        return this;
+    }
+    firstLoanLtv(filter) {
+        this.criteria.firstLoanLtv = filter;
+        return this;
+    }
+    firstLoanInterestRate(filter) {
+        this.criteria.firstLoanInterestRate = filter;
+        return this;
+    }
+    secondLoanInterestRate(filter) {
+        this.criteria.secondLoanInterestRate = filter;
+        return this;
+    }
+    thirdLoanInterestRate(filter) {
+        this.criteria.thirdLoanInterestRate = filter;
+        return this;
+    }
+    fourthLoanInterestRate(filter) {
+        this.criteria.fourthLoanInterestRate = filter;
+        return this;
+    }
+    firstLoanType(filter) {
+        this.criteria.firstLoanType = filter;
+        return this;
+    }
+    secondLoanType(filter) {
+        this.criteria.secondLoanType = filter;
+        return this;
+    }
+    thirdLoanType(filter) {
+        this.criteria.thirdLoanType = filter;
+        return this;
+    }
+    fourthLoanType(filter) {
+        this.criteria.fourthLoanType = filter;
+        return this;
+    }
+    firstLoanRecordingDate(filter) {
+        this.criteria.firstLoanRecordingDate = filter;
+        return this;
+    }
+    lastLoanRecordingDate(filter) {
+        this.criteria.lastLoanRecordingDate = filter;
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.OpenLienSearchCriteriaBuilder = OpenLienSearchCriteriaBuilder;
+/**
+ * Builder for owner search criteria
+ */
+class OwnerSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new OwnerSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    firstName(filter) {
+        this.criteria.firstName = filter;
+        return this;
+    }
+    lastName(filter) {
+        this.criteria.lastName = filter;
+        return this;
+    }
+    ownerOccupied(value) {
+        this.criteria.ownerOccupied = { equals: value };
+        return this;
+    }
+    mailingStreet(filter) {
+        this.criteria.mailingStreet = filter;
+        return this;
+    }
+    mailingCity(filter) {
+        this.criteria.mailingCity = filter;
+        return this;
+    }
+    mailingState(filter) {
+        this.criteria.mailingState = filter;
+        return this;
+    }
+    mailingZip(filter) {
+        this.criteria.mailingZip = filter;
+        return this;
+    }
+    ownerStatusType(filter) {
+        this.criteria.ownerStatusType = filter;
+        return this;
+    }
+    lengthOfResidenceMonths(filter) {
+        this.criteria.lengthOfResidenceMonths = filter;
+        return this;
+    }
+    lengthOfResidenceYears(filter) {
+        this.criteria.lengthOfResidenceYears = filter;
+        return this;
+    }
+    ownershipStartDate(filter) {
+        this.criteria.ownershipStartDate = filter;
+        return this;
+    }
+    mailingAddressHash(filter) {
+        this.criteria.mailingAddressHash = filter;
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.OwnerSearchCriteriaBuilder = OwnerSearchCriteriaBuilder;
+/**
+ * Builder for permit search criteria
+ */
+class PermitSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new PermitSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    permitCount(filter) {
+        this.criteria.permitCount = filter;
+        return this;
+    }
+    latestDate(filter) {
+        this.criteria.latestDate = filter;
+        return this;
+    }
+    earliestDate(filter) {
+        this.criteria.earliestDate = filter;
+        return this;
+    }
+    totalJobValue(filter) {
+        this.criteria.totalJobValue = filter;
+        return this;
+    }
+    allTags(filter) {
+        this.criteria.allTags = filter;
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.PermitSearchCriteriaBuilder = PermitSearchCriteriaBuilder;
+/**
+ * Builder for property owner profile search criteria
+ */
+class PropertyOwnerProfileSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new PropertyOwnerProfileSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    propertiesCount(filter) {
+        this.criteria.propertiesCount = filter;
+        return this;
+    }
+    propertiesTotalEquity(filter) {
+        this.criteria.propertiesTotalEquity = filter;
+        return this;
+    }
+    propertiesTotalEstimatedValue(filter) {
+        this.criteria.propertiesTotalEstimatedValue = filter;
+        return this;
+    }
+    mortgagesTotalBalance(filter) {
+        this.criteria.mortgagesTotalBalance = filter;
+        return this;
+    }
+    mortgagesCount(filter) {
+        this.criteria.mortgagesCount = filter;
+        return this;
+    }
+    mortgagesAverageBalance(filter) {
+        this.criteria.mortgagesAverageBalance = filter;
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.PropertyOwnerProfileSearchCriteriaBuilder = PropertyOwnerProfileSearchCriteriaBuilder;
+/**
+ * Builder for sale search criteria
+ */
+class SaleSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new SaleSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    lastSalePrice(filter) {
+        this.criteria.lastSalePrice = filter;
+        return this;
+    }
+    lastSaleDate(filter) {
+        this.criteria.lastSaleDate = filter;
+        return this;
+    }
+    lastSaleDocumentType(filter) {
+        this.criteria.lastSaleDocumentType = filter;
+        return this;
+    }
+    lastSalePricePerSquareFoot(filter) {
+        this.criteria.lastSalePricePerSquareFoot = filter;
+        return this;
+    }
+    flipLength(filter) {
+        this.criteria.flipLength = filter;
+        return this;
+    }
+    flipLengthCategory(filter) {
+        this.criteria.flipLengthCategory = filter;
+        return this;
+    }
+    flipProfit(filter) {
+        this.criteria.flipProfit = filter;
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.SaleSearchCriteriaBuilder = SaleSearchCriteriaBuilder;
+/**
+ * Builder for tax search criteria
+ */
+class TaxSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new TaxSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    taxDelinquentYear(filter) {
+        this.criteria.taxDelinquentYear = filter;
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.TaxSearchCriteriaBuilder = TaxSearchCriteriaBuilder;
+/**
+ * Builder for valuation search criteria
+ */
+class ValuationSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new ValuationSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    estimatedValue(filter) {
+        this.criteria.estimatedValue = filter;
+        return this;
+    }
+    ltv(filter) {
+        this.criteria.ltv = filter;
+        return this;
+    }
+    equityPercent(filter) {
+        this.criteria.equityPercent = filter;
+        return this;
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.ValuationSearchCriteriaBuilder = ValuationSearchCriteriaBuilder;
+/**
+ * Builder for OR search criteria
+ */
+class OrSearchCriteriaBuilder {
+    constructor() {
+        this.criteria = {};
+    }
+    static from(criteria) {
+        const builder = new OrSearchCriteriaBuilder();
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    listing() {
+        return {
+            status: (filter) => {
+                if (!this.criteria.listing) {
+                    this.criteria.listing = {};
+                }
+                this.criteria.listing.status = filter;
+                return this.criteria.listing.status;
+            },
+        };
+    }
+    sale() {
+        return {
+            lastSaleDate: (filter) => {
+                if (!this.criteria.sale) {
+                    this.criteria.sale = {};
+                }
+                this.criteria.sale.lastSaleDate = filter;
+                return this.criteria.sale.lastSaleDate;
+            },
+        };
+    }
+    build() {
+        return this.criteria;
+    }
+}
+exports.OrSearchCriteriaBuilder = OrSearchCriteriaBuilder;
+/**
+ * Main builder for search criteria
+ *
+ * Note: The API requires a query field (returns 400 without it), even when
+ * address filters are provided. Query appears to be a geographic scope string
+ * (e.g., "US", "AZ", "Maricopa County, AZ"). You can set it via constructor
+ * or using the query() method.
+ */
+class SearchCriteriaBuilder extends BaseBuilder {
+    /**
+     * Creates a new SearchCriteriaBuilder
+     *
+     * @param query - Geographic scope for the search (e.g., "US", "AZ", "Maricopa County, AZ").
+     *                This is required by the API even when address filters are provided.
+     *                The query defines the geographic boundary/scope for property searches.
+     */
+    constructor(query) {
+        super();
+        this.criteria = {};
+        this.criteria.query = query;
+    }
+    static from(criteria) {
+        const builder = new SearchCriteriaBuilder(criteria.query);
+        builder.criteria = { ...criteria };
+        return builder;
+    }
+    /**
+     * Sets the geographic scope for the search
+     *
+     * @param value - Geographic scope string (e.g., "US", "AZ", "Maricopa County, AZ").
+     *                This defines the geographic boundary/scope for property searches.
+     *                Required by the API even when address filters are provided.
+     * @returns This builder instance for method chaining
+     */
+    query(value) {
+        this.criteria.query = value;
+        return this;
+    }
+    quickList(value) {
+        this.criteria.quickList = value;
+        return this;
+    }
+    quickLists(values) {
+        this.criteria.quickLists = values;
+        return this;
+    }
+    orQuickLists(values) {
+        this.criteria.orQuickLists = values;
+        return this;
+    }
+    address(criteriaOrConfigurator) {
+        return this.setPropertyWithBuilderClass("address", criteriaOrConfigurator, AddressSearchCriteriaBuilder);
+    }
+    assessment(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new AssessmentSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.assessment = builder.build();
+        }
+        else {
+            this.criteria.assessment = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    building(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new BuildingSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.building = builder.build();
+        }
+        else {
+            this.criteria.building = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    compAddress(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new CompAddressSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.compAddress = builder.build();
+        }
+        else {
+            this.criteria.compAddress = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    demographics(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new DemographicsSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.demographics = builder.build();
+        }
+        else {
+            this.criteria.demographics = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    foreclosure(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new ForeclosureSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.foreclosure = builder.build();
+        }
+        else {
+            this.criteria.foreclosure = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    general(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new GeneralSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.general = builder.build();
+        }
+        else {
+            this.criteria.general = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    ids(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new IdsSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.ids = builder.build();
+        }
+        else {
+            this.criteria.ids = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    intel(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new IntelSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.intel = builder.build();
+        }
+        else {
+            this.criteria.intel = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    involuntaryLien(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new InvoluntaryLienSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.involuntaryLien = builder.build();
+        }
+        else {
+            this.criteria.involuntaryLien = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    legal(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new LegalSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.legal = builder.build();
+        }
+        else {
+            this.criteria.legal = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    listing(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new ListingSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.listing = builder.build();
+        }
+        else {
+            this.criteria.listing = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    lot(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new LotSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.lot = builder.build();
+        }
+        else {
+            this.criteria.lot = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    openLien(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new OpenLienSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.openLien = builder.build();
+        }
+        else {
+            this.criteria.openLien = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    owner(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new OwnerSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.owner = builder.build();
+        }
+        else {
+            this.criteria.owner = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    permit(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new PermitSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.permit = builder.build();
+        }
+        else {
+            this.criteria.permit = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    propertyOwnerProfile(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new PropertyOwnerProfileSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.propertyOwnerProfile = builder.build();
+        }
+        else {
+            this.criteria.propertyOwnerProfile = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    sale(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new SaleSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.sale = builder.build();
+        }
+        else {
+            this.criteria.sale = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    tax(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new TaxSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.tax = builder.build();
+        }
+        else {
+            this.criteria.tax = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    valuation(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new ValuationSearchCriteriaBuilder();
+            criteriaOrConfigurator(builder);
+            this.criteria.valuation = builder.build();
+        }
+        else {
+            this.criteria.valuation = criteriaOrConfigurator;
+        }
+        return this;
+    }
+    or(criteria) {
+        this.criteria.or = criteria;
+        return this;
+    }
+}
+exports.SearchCriteriaBuilder = SearchCriteriaBuilder;
+/**
+ * Builder for delivery configuration
+ */
+class DeliveryConfigBuilder {
+    constructor() {
+        this.config = {};
+    }
+    static from(config) {
+        const builder = new DeliveryConfigBuilder();
+        builder.config = { ...config };
+        return builder;
+    }
+    webhook(url, headers, errorUrl) {
+        this.config.type = "webhook";
+        this.config.url = url;
+        if (errorUrl) {
+            this.config.errorUrl = errorUrl;
+        }
+        if (headers) {
+            this.config.headers = headers;
+        }
+        return this;
+    }
+    kinesis(streamName, region, iamAccessKeyId, iamSecretAccessKey) {
+        this.config.type = "kinesis";
+        this.config.streamName = streamName;
+        this.config.region = region;
+        this.config.iamAccessKeyId = iamAccessKeyId;
+        this.config.iamSecretAccessKey = iamSecretAccessKey;
+        return this;
+    }
+    build() {
+        if (!this.config.type) {
+            throw new Error("Delivery type (webhook or kinesis) is required");
+        }
+        if (this.config.type === "webhook" && !this.config.url) {
+            throw new Error("URL is required for webhook delivery");
+        }
+        if (this.config.type === "kinesis") {
+            if (!this.config.streamName ||
+                !this.config.region ||
+                !this.config.iamAccessKeyId ||
+                !this.config.iamSecretAccessKey) {
+                throw new Error("Stream name, region, IAM access key ID, and secret access key are required for Kinesis delivery");
+            }
+        }
+        return this.config;
+    }
+}
+exports.DeliveryConfigBuilder = DeliveryConfigBuilder;
+/**
+ * Main builder for property subscription requests
+ */
+class PropertySubscriptionBuilder extends BaseBuilder {
+    static from(request) {
+        const builder = new PropertySubscriptionBuilder();
+        builder.searchCriteria(request.searchCriteria);
+        builder.deliveryConfig(request.deliveryConfig);
+        return builder;
+    }
+    searchCriteria(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new SearchCriteriaBuilder("");
+            criteriaOrConfigurator(builder);
+            this.criteria.searchCriteria = builder.build();
+            this.builders.searchCriteria = undefined;
+        }
+        else {
+            this.criteria.searchCriteria = criteriaOrConfigurator;
+            this.builders.searchCriteria = undefined;
+        }
+        return this;
+    }
+    deliveryConfig(configOrConfigurator) {
+        if (typeof configOrConfigurator === "function") {
+            const builder = new DeliveryConfigBuilder();
+            configOrConfigurator(builder);
+            this.criteria.deliveryConfig = builder.build();
+            this.builders.deliveryConfig = undefined;
+        }
+        else {
+            this.criteria.deliveryConfig = configOrConfigurator;
+            this.builders.deliveryConfig = undefined;
+        }
+        return this;
+    }
+    build() {
+        if (!this.criteria.searchCriteria) {
+            throw new Error("Search criteria is required");
+        }
+        if (!this.criteria.deliveryConfig) {
+            throw new Error("Delivery configuration is required");
+        }
+        return {
+            searchCriteria: this.criteria.searchCriteria,
+            deliveryConfig: this.criteria.deliveryConfig,
+        };
+    }
+}
+exports.PropertySubscriptionBuilder = PropertySubscriptionBuilder;
+/**
+ * Builder for property lookup request items
+ */
+class PropertyLookupRequestItemBuilder {
+    constructor() {
+        this.item = {};
+    }
+    static from(item) {
+        const builder = new PropertyLookupRequestItemBuilder();
+        builder.item = { ...item };
+        return builder;
+    }
+    address(address) {
+        this.item.address = address;
+        return this;
+    }
+    propertyId(propertyId) {
+        this.item.propertyId = propertyId;
+        return this;
+    }
+    hash(hash) {
+        this.item.hash = hash;
+        return this;
+    }
+    apn(apn) {
+        this.item.apn = apn;
+        return this;
+    }
+    countyFipsCode(countyFipsCode) {
+        this.item.countyFipsCode = countyFipsCode;
+        return this;
+    }
+    requestId(requestId) {
+        this.item.requestId = requestId;
+        return this;
+    }
+    build() {
+        return this.item;
+    }
+}
+exports.PropertyLookupRequestItemBuilder = PropertyLookupRequestItemBuilder;
+/**
+ * Builder for property lookup options
+ * PropertyLookupOptions has 40+ fields, so a builder provides a cleaner API
+ */
+class PropertyLookupOptionsBuilder {
+    constructor() {
+        this.options = {};
+    }
+    static from(options) {
+        const builder = new PropertyLookupOptionsBuilder();
+        builder.options = { ...options };
+        return builder;
+    }
+    pagination(skip, take) {
+        this.options.skip = skip;
+        this.options.take = take;
+        return this;
+    }
+    skip(skip) {
+        this.options.skip = skip;
+        return this;
+    }
+    take(take) {
+        this.options.take = take;
+        return this;
+    }
+    showRequests(show) {
+        this.options.showRequests = show;
+        return this;
+    }
+    areaPolygon(show) {
+        this.options.areaPolygon = show;
+        return this;
+    }
+    quicklistCounts(show) {
+        this.options.quicklistCounts = show;
+        return this;
+    }
+    distance(miles, yards, feet, kilometers, meters) {
+        this.options.useDistance = true;
+        if (miles !== undefined)
+            this.options.distanceMiles = miles;
+        if (yards !== undefined)
+            this.options.distanceYards = yards;
+        if (feet !== undefined)
+            this.options.distanceFeet = feet;
+        if (kilometers !== undefined)
+            this.options.distanceKilometers = kilometers;
+        if (meters !== undefined)
+            this.options.distanceMeters = meters;
+        return this;
+    }
+    boundingBox(nw, se) {
+        this.options.useBoundingBox = true;
+        this.options.boundingBoxNw = nw;
+        this.options.boundingBoxSe = se;
+        return this;
+    }
+    bedrooms(min, max) {
+        this.options.useBedrooms = true;
+        if (min !== undefined)
+            this.options.minBedrooms = min;
+        if (max !== undefined)
+            this.options.maxBedrooms = max;
+        return this;
+    }
+    bathrooms(min, max) {
+        this.options.useBathrooms = true;
+        if (min !== undefined)
+            this.options.minBathrooms = min;
+        if (max !== undefined)
+            this.options.maxBathrooms = max;
+        return this;
+    }
+    stories(min, max) {
+        this.options.useStories = true;
+        if (min !== undefined)
+            this.options.minStories = min;
+        if (max !== undefined)
+            this.options.maxStories = max;
+        return this;
+    }
+    area(minPercent, maxPercent) {
+        this.options.useArea = true;
+        if (minPercent !== undefined)
+            this.options.minAreaPercent = minPercent;
+        if (maxPercent !== undefined)
+            this.options.maxAreaPercent = maxPercent;
+        return this;
+    }
+    yearBuilt(min, max) {
+        this.options.useYearBuilt = true;
+        if (min !== undefined)
+            this.options.minYearBuilt = min;
+        if (max !== undefined)
+            this.options.maxYearBuilt = max;
+        return this;
+    }
+    lotSize(minPercent, maxPercent) {
+        this.options.useLotSize = true;
+        if (minPercent !== undefined)
+            this.options.minLotSizePercent = minPercent;
+        if (maxPercent !== undefined)
+            this.options.maxLotSizePercent = maxPercent;
+        return this;
+    }
+    skipTrace(enabled) {
+        this.options.skipTrace = enabled;
+        return this;
+    }
+    aggregateLoanTypes(enabled) {
+        this.options.aggregateLoanTypes = enabled;
+        return this;
+    }
+    images(enabled) {
+        this.options.images = enabled;
+        return this;
+    }
+    dateFormat(format) {
+        this.options.dateFormat = format;
+        return this;
+    }
+    sort(field, order, sessionId) {
+        this.options.sort = { field, order, sessionId };
+        return this;
+    }
+    useSubdivision(enabled) {
+        this.options.useSubdivision = enabled;
+        return this;
+    }
+    build() {
+        return this.options;
+    }
+}
+exports.PropertyLookupOptionsBuilder = PropertyLookupOptionsBuilder;
+/**
+ * Builder for async property lookup options
+ * Extends PropertyLookupOptionsBuilder with async-specific methods like webhook
+ */
+class AsyncPropertyLookupOptionsBuilder extends PropertyLookupOptionsBuilder {
+    static from(options) {
+        const builder = new AsyncPropertyLookupOptionsBuilder();
+        builder.options = { ...options };
+        return builder;
+    }
+    webhook(url, errorUrl) {
+        this.options.webhookUrl = url;
+        if (errorUrl) {
+            this.options.errorWebhookUrl = errorUrl;
+        }
+        return this;
+    }
+}
+exports.AsyncPropertyLookupOptionsBuilder = AsyncPropertyLookupOptionsBuilder;
+/**
+ * Builder for property lookup requests
+ */
+class PropertyLookupRequestBuilder extends BaseBuilder {
+    constructor() {
+        super(...arguments);
+        this.requestItems = [];
+    }
+    static from(request) {
+        const builder = new PropertyLookupRequestBuilder();
+        builder.requestItems = [...request.requests];
+        if (request.options) {
+            builder.options(request.options);
+        }
+        return builder;
+    }
+    items(items) {
+        this.requestItems = items;
+        return this;
+    }
+    addItem(item) {
+        this.requestItems.push(item);
+        return this;
+    }
+    addItemBuilder(builder) {
+        this.requestItems.push(builder.build());
+        return this;
+    }
+    options(optionsOrConfigurator) {
+        return this.setPropertyWithBuilderClass("options", optionsOrConfigurator, PropertyLookupOptionsBuilder);
+    }
+    build() {
+        const request = {
+            requests: this.requestItems,
+        };
+        if (this.builders.options) {
+            request.options = this.builders.options.build();
+        }
+        else if (this.criteria.options) {
+            request.options = this.criteria.options;
+        }
+        return request;
+    }
+}
+exports.PropertyLookupRequestBuilder = PropertyLookupRequestBuilder;
+/**
+ * Builder for property search requests
+ */
+class PropertySearchRequestBuilder extends BaseBuilder {
+    static from(request) {
+        const builder = new PropertySearchRequestBuilder();
+        builder.searchCriteria(request.searchCriteria);
+        if (request.options) {
+            builder.options(request.options);
+        }
+        return builder;
+    }
+    searchCriteria(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new SearchCriteriaBuilder("");
+            criteriaOrConfigurator(builder);
+            this.criteria.searchCriteria = builder.build();
+            this.builders.searchCriteria = undefined;
+        }
+        else {
+            this.criteria.searchCriteria = criteriaOrConfigurator;
+            this.builders.searchCriteria = undefined;
+        }
+        return this;
+    }
+    options(optionsOrConfigurator) {
+        return this.setPropertyWithBuilderClass("options", optionsOrConfigurator, PropertyLookupOptionsBuilder);
+    }
+    build() {
+        if (!this.criteria.searchCriteria) {
+            throw new Error("Search criteria is required");
+        }
+        const request = {
+            searchCriteria: this.criteria.searchCriteria,
+        };
+        if (this.builders.options) {
+            request.options = this.builders.options.build();
+        }
+        else if (this.criteria.options) {
+            request.options = this.criteria.options;
+        }
+        return request;
+    }
+}
+exports.PropertySearchRequestBuilder = PropertySearchRequestBuilder;
+/**
+ * Builder for property search async requests
+ */
+class PropertySearchAsyncRequestBuilder extends BaseBuilder {
+    static from(request) {
+        const builder = new PropertySearchAsyncRequestBuilder();
+        builder.searchCriteria(request.searchCriteria);
+        if (request.options) {
+            builder.options(request.options);
+        }
+        return builder;
+    }
+    searchCriteria(criteriaOrConfigurator) {
+        if (typeof criteriaOrConfigurator === "function") {
+            const builder = new SearchCriteriaBuilder("");
+            criteriaOrConfigurator(builder);
+            this.criteria.searchCriteria = builder.build();
+            this.builders.searchCriteria = undefined;
+        }
+        else {
+            this.criteria.searchCriteria = criteriaOrConfigurator;
+            this.builders.searchCriteria = undefined;
+        }
+        return this;
+    }
+    options(optionsOrConfigurator) {
+        return this.setPropertyWithBuilderClass("options", optionsOrConfigurator, PropertyLookupOptionsBuilder);
+    }
+    build() {
+        if (!this.criteria.searchCriteria) {
+            throw new Error("Search criteria is required");
+        }
+        const request = {
+            searchCriteria: this.criteria.searchCriteria,
+        };
+        if (this.builders.options) {
+            request.options = this.builders.options.build();
+        }
+        else if (this.criteria.options) {
+            request.options = this.criteria.options;
+        }
+        return request;
+    }
+}
+exports.PropertySearchAsyncRequestBuilder = PropertySearchAsyncRequestBuilder;
+/**
+ * Builder for property lookup async requests
+ */
+class PropertyLookupAsyncRequestBuilder extends BaseBuilder {
+    constructor() {
+        super(...arguments);
+        this.requestItems = [];
+    }
+    static from(request) {
+        const builder = new PropertyLookupAsyncRequestBuilder();
+        builder.requestItems = [...request.requests];
+        if (request.options) {
+            builder.options(request.options);
+        }
+        return builder;
+    }
+    items(items) {
+        this.requestItems = items;
+        return this;
+    }
+    addItem(item) {
+        this.requestItems.push(item);
+        return this;
+    }
+    addItemBuilder(builder) {
+        this.requestItems.push(builder.build());
+        return this;
+    }
+    options(optionsOrConfigurator) {
+        return this.setPropertyWithBuilderClass("options", optionsOrConfigurator, PropertyLookupOptionsBuilder);
+    }
+    build() {
+        const request = {
+            requests: this.requestItems,
+        };
+        if (this.builders.options) {
+            request.options = this.builders.options.build();
+        }
+        else if (this.criteria.options) {
+            request.options = this.criteria.options;
+        }
+        return request;
+    }
+}
+exports.PropertyLookupAsyncRequestBuilder = PropertyLookupAsyncRequestBuilder;
+/**
+ * Builder for property permit request filters
+ */
+class PropertyPermitRequestBuilder {
+    constructor() {
+        this.request = {};
+        this.options = {};
+    }
+    static from(permitRequest) {
+        const builder = new PropertyPermitRequestBuilder();
+        builder.request = { ...permitRequest.request };
+        builder.options = permitRequest.options ? { ...permitRequest.options } : {};
+        return builder;
+    }
+    // Address/identifier methods
+    address(address) {
+        this.request.address = address;
+        return this;
+    }
+    hash(hash) {
+        this.request.hash = hash;
+        return this;
+    }
+    propertyId(propertyId) {
+        this.request.propertyId = propertyId;
+        return this;
+    }
+    apn(apn) {
+        this.request.apn = apn;
+        return this;
+    }
+    countyFipsCode(countyFipsCode) {
+        this.request.countyFipsCode = countyFipsCode;
+        return this;
+    }
+    // Filter methods
+    allTags(filter) {
+        this.request.allTags = filter;
+        return this;
+    }
+    allTagsBuilder(filter) {
+        this.request.allTags = filter;
+        return this;
+    }
+    description(filter) {
+        this.request.description = filter;
+        return this;
+    }
+    descriptionBuilder(filter) {
+        this.request.description = filter;
+        return this;
+    }
+    endDate(filter) {
+        this.request.endDate = filter;
+        return this;
+    }
+    endDateBuilder(filter) {
+        this.request.endDate = filter;
+        return this;
+    }
+    fileDate(filter) {
+        this.request.fileDate = filter;
+        return this;
+    }
+    fileDateBuilder(filter) {
+        this.request.fileDate = filter;
+        return this;
+    }
+    finalDate(filter) {
+        this.request.finalDate = filter;
+        return this;
+    }
+    finalDateBuilder(filter) {
+        this.request.finalDate = filter;
+        return this;
+    }
+    issueDate(filter) {
+        this.request.issueDate = filter;
+        return this;
+    }
+    issueDateBuilder(filter) {
+        this.request.issueDate = filter;
+        return this;
+    }
+    jobValue(filter) {
+        this.request.jobValue = filter;
+        return this;
+    }
+    jobValueBuilder(filter) {
+        this.request.jobValue = filter;
+        return this;
+    }
+    startDate(filter) {
+        this.request.startDate = filter;
+        return this;
+    }
+    startDateBuilder(filter) {
+        this.request.startDate = filter;
+        return this;
+    }
+    status(filter) {
+        this.request.status = filter;
+        return this;
+    }
+    statusBuilder(filter) {
+        this.request.status = filter;
+        return this;
+    }
+    subType(filter) {
+        this.request.subType = filter;
+        return this;
+    }
+    subTypeBuilder(filter) {
+        this.request.subType = filter;
+        return this;
+    }
+    type(filter) {
+        this.request.type = filter;
+        return this;
+    }
+    typeBuilder(filter) {
+        this.request.type = filter;
+        return this;
+    }
+    // Options methods
+    pagination(skip, take) {
+        this.options.skip = skip;
+        this.options.take = take;
+        return this;
+    }
+    skip(skip) {
+        this.options.skip = skip;
+        return this;
+    }
+    take(take) {
+        this.options.take = take;
+        return this;
+    }
+    sessionId(sessionId) {
+        this.options.sessionId = sessionId;
+        return this;
+    }
+    dateFormat(format) {
+        this.options.dateFormat = format;
+        return this;
+    }
+    showRequests(show) {
+        this.options.showRequests = show;
+        return this;
+    }
+    showOptions(show) {
+        this.options.showOptions = show;
+        return this;
+    }
+    showMeta(show) {
+        this.options.showMeta = show;
+        return this;
+    }
+    sort(field, order) {
+        this.options.sort = { field, order };
+        return this;
+    }
+    build() {
+        const hasOptions = Object.keys(this.options).length > 0;
+        return {
+            request: this.request,
+            options: hasOptions ? this.options : undefined,
+        };
+    }
+}
+exports.PropertyPermitRequestBuilder = PropertyPermitRequestBuilder;