@land-catalyst/batch-data-sdk 1.2.0 → 1.2.2

package/dist/core/types.d.ts

@@ -343,7 +343,7 @@ export interface OrSearchCriteria {
  * 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";
+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" | "senior-owner" | "trust-owned";
 /**
  * QuickList value that can be prefixed with "not-" to exclude
  */

package/dist/index.d.ts

@@ -12,6 +12,9 @@ export * from "./client/client.interface";
 export * from "./core/logger.interface";
 export * from "./property-field/metadata";
 export * from "./property-field/utils";
+export * from "./property-field/search-criteria-filter-context";
+export type { SearchCriteriaFilterContext, SearchCriteriaFilterType, } from "./property-field/search-criteria-filter-context";
+export * from "./property-field/search-criteria-ai-context";
 export { type PropertyFieldPathType, type PropertyFieldValueType, type FieldMetadataForPath, } from "./property-field/types";
 export type { SearchCriteriaFieldMapping, SearchCriteriaFieldMetadata, } from "./property-field/utils";
 export type { RequestMiddleware, ResponseMiddleware, ErrorMiddleware, HttpMiddleware, } from "./client/client";

package/dist/index.js

@@ -28,3 +28,5 @@ __exportStar(require("./client/client.interface"), exports);
 __exportStar(require("./core/logger.interface"), exports);
 __exportStar(require("./property-field/metadata"), exports);
 __exportStar(require("./property-field/utils"), exports);
+__exportStar(require("./property-field/search-criteria-filter-context"), exports);
+__exportStar(require("./property-field/search-criteria-ai-context"), exports);

package/dist/property-field/search-criteria-ai-context.d.ts

@@ -0,0 +1,117 @@
+/**
+ * SearchCriteria AI Context Builder
+ *
+ * Builds complete context for AI services to generate SearchCriteria from natural language.
+ * This includes all domain documentation, filter types, examples, and rules.
+ */
+/**
+ * Domain metadata with description
+ */
+export interface SearchCriteriaDomain {
+    /**
+     * Domain name (e.g., "address", "building", "assessment")
+     */
+    name: string;
+    /**
+     * Response group name used to fetch filter contexts (e.g., "address", "building")
+     * If not provided, this domain doesn't have filterable fields
+     */
+    responseGroup?: string;
+    /**
+     * Human-readable description of what this domain filters
+     */
+    description: string;
+}
+/**
+ * All available SearchCriteria domains with their descriptions
+ */
+export declare const SEARCH_CRITERIA_DOMAINS: SearchCriteriaDomain[];
+/**
+ * Array of all valid SearchCriteria domain names (for autocomplete)
+ * Using `as const` preserves literal types for better IDE autocomplete
+ */
+export declare const SEARCH_CRITERIA_DOMAIN_NAMES: readonly ["query", "address", "assessment", "building", "lot", "owner", "sale", "tax", "valuation", "listing", "openLien", "foreclosure", "quickList"];
+/**
+ * Type representing valid SearchCriteria domain names
+ * This union type provides better autocomplete in IDEs
+ */
+export type SearchCriteriaDomainName = (typeof SEARCH_CRITERIA_DOMAIN_NAMES)[number];
+/**
+ * Options for building AI context
+ */
+export interface SearchCriteriaAIContextOptions {
+    /**
+     * Maximum number of fields to include per domain (to avoid overwhelming the prompt)
+     * If not specified, all fields will be included
+     */
+    maxFieldsPerDomain?: number;
+    /**
+     * Maximum number of examples per field
+     * If not specified, all examples will be included
+     */
+    maxExamplesPerField?: number;
+}
+/**
+ * Build domain context documentation for specified domains
+ * @param domains Array of domain names to include (e.g., ["address", "building", "assessment"])
+ *                If undefined or empty array, includes all domains (default)
+ *                Type-safe: only valid domain names from SEARCH_CRITERIA_DOMAINS are allowed
+ * @param options Options for customizing the context (applies to all specified domains)
+ * @returns Formatted domain documentation string
+ * @example
+ * ```typescript
+ * // Get context for all domains (default)
+ * const allContext = buildSearchCriteriaContext();
+ *
+ * // Get context for specific domains
+ * const context = buildSearchCriteriaContext(["address", "building", "assessment"]);
+ *
+ * // Get context for all domains with options
+ * const allContextWithOptions = buildSearchCriteriaContext(undefined, { maxFieldsPerDomain: 5 });
+ *
+ * // Get context for specific domains with options
+ * const selectiveContext = buildSearchCriteriaContext(["address", "building"], { maxFieldsPerDomain: 5 });
+ * ```
+ */
+export declare function buildSearchCriteriaContext(domains?: SearchCriteriaDomainName[], options?: SearchCriteriaAIContextOptions): string;
+/**
+ * Build complete system prompt for AI to generate SearchCriteria from natural language
+ * @param domains Optional domain names to include. If not specified, includes all domains.
+ *                Only domains that exist in SEARCH_CRITERIA_DOMAINS are allowed
+ * @param options Options for customizing the context (applies to all specified domains)
+ * @returns Complete system prompt string
+ * @example
+ * ```typescript
+ * // Full context with all domains
+ * const systemPrompt = buildSearchCriteriaSystemPrompt();
+ *
+ * // Selective context for specific domains
+ * const systemPrompt = buildSearchCriteriaSystemPrompt(["address", "building", "assessment"]);
+ *
+ * // All domains with options
+ * const systemPrompt = buildSearchCriteriaSystemPrompt(undefined, { maxFieldsPerDomain: 5 });
+ *
+ * // Specific domains with options
+ * const systemPrompt = buildSearchCriteriaSystemPrompt(["address", "building"], { maxFieldsPerDomain: 5 });
+ * ```
+ */
+export declare function buildSearchCriteriaSystemPrompt(domains?: SearchCriteriaDomainName[], options?: SearchCriteriaAIContextOptions): string;
+/**
+ * Get context documentation for a specific domain
+ * @param domainName The domain name (e.g., "address", "building", "assessment")
+ * @param options Options for customizing the context
+ * @returns Formatted documentation string for the domain
+ * @example
+ * ```typescript
+ * const addressContext = getDomainContext("address");
+ * // Returns formatted documentation for all address fields
+ * ```
+ */
+export declare function getDomainContext(domainName: string, options?: SearchCriteriaAIContextOptions): string;
+/**
+ * Build user prompt with existing criteria context
+ * @param userPrompt The user's natural language prompt
+ * @param existingCriteria Optional existing search criteria to modify
+ * @returns Formatted user prompt string
+ */
+export declare function buildSearchCriteriaUserPrompt(userPrompt: string, existingCriteria?: unknown): string;

package/dist/property-field/search-criteria-ai-context.js

@@ -0,0 +1,351 @@
+"use strict";
+/**
+ * SearchCriteria AI Context Builder
+ *
+ * Builds complete context for AI services to generate SearchCriteria from natural language.
+ * This includes all domain documentation, filter types, examples, and rules.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEARCH_CRITERIA_DOMAIN_NAMES = exports.SEARCH_CRITERIA_DOMAINS = void 0;
+exports.buildSearchCriteriaContext = buildSearchCriteriaContext;
+exports.buildSearchCriteriaSystemPrompt = buildSearchCriteriaSystemPrompt;
+exports.getDomainContext = getDomainContext;
+exports.buildSearchCriteriaUserPrompt = buildSearchCriteriaUserPrompt;
+const search_criteria_filter_context_1 = require("./search-criteria-filter-context");
+/**
+ * All available SearchCriteria domains with their descriptions
+ */
+exports.SEARCH_CRITERIA_DOMAINS = [
+    {
+        name: "query",
+        description: 'Geographic scope string (required, e.g., "US", "AZ", "Maricopa County, AZ", "Phoenix, AZ")',
+    },
+    {
+        name: "address",
+        responseGroup: "address",
+        description: "Address filters for location-based searches",
+    },
+    {
+        name: "assessment",
+        responseGroup: "assessment",
+        description: "Property assessment and market value filters",
+    },
+    {
+        name: "building",
+        responseGroup: "building",
+        description: "Building characteristics and features",
+    },
+    {
+        name: "lot",
+        responseGroup: "lot",
+        description: "Lot characteristics and dimensions",
+    },
+    {
+        name: "owner",
+        responseGroup: "owner",
+        description: "Owner information and characteristics",
+    },
+    {
+        name: "sale",
+        responseGroup: "sale",
+        description: "Sale history and transaction information",
+    },
+    {
+        name: "tax",
+        responseGroup: "tax",
+        description: "Tax information and delinquency status",
+    },
+    {
+        name: "valuation",
+        responseGroup: "valuation",
+        description: "Property valuation estimates",
+    },
+    {
+        name: "listing",
+        responseGroup: "listing",
+        description: "Current listing information",
+    },
+    {
+        name: "openLien",
+        responseGroup: "openLien",
+        description: "Open mortgage and lien information",
+    },
+    {
+        name: "foreclosure",
+        responseGroup: "foreclosure",
+        description: "Foreclosure status and auction information",
+    },
+    {
+        name: "quickList",
+        responseGroup: "quickList",
+        description: "Pre-defined quick filters (owner-occupied, vacant, absentee-owner, high-equity, low-equity, free-and-clear, active-listing, recently-sold, preforeclosure, tax-default, etc.). Can be negated with 'not-' prefix.",
+    },
+];
+/**
+ * Array of all valid SearchCriteria domain names (for autocomplete)
+ * Using `as const` preserves literal types for better IDE autocomplete
+ */
+exports.SEARCH_CRITERIA_DOMAIN_NAMES = [
+    "query",
+    "address",
+    "assessment",
+    "building",
+    "lot",
+    "owner",
+    "sale",
+    "tax",
+    "valuation",
+    "listing",
+    "openLien",
+    "foreclosure",
+    "quickList",
+];
+/**
+ * Build domain context documentation for specified domains
+ * @param domains Array of domain names to include (e.g., ["address", "building", "assessment"])
+ *                If undefined or empty array, includes all domains (default)
+ *                Type-safe: only valid domain names from SEARCH_CRITERIA_DOMAINS are allowed
+ * @param options Options for customizing the context (applies to all specified domains)
+ * @returns Formatted domain documentation string
+ * @example
+ * ```typescript
+ * // Get context for all domains (default)
+ * const allContext = buildSearchCriteriaContext();
+ *
+ * // Get context for specific domains
+ * const context = buildSearchCriteriaContext(["address", "building", "assessment"]);
+ *
+ * // Get context for all domains with options
+ * const allContextWithOptions = buildSearchCriteriaContext(undefined, { maxFieldsPerDomain: 5 });
+ *
+ * // Get context for specific domains with options
+ * const selectiveContext = buildSearchCriteriaContext(["address", "building"], { maxFieldsPerDomain: 5 });
+ * ```
+ */
+function buildSearchCriteriaContext(domains, options) {
+    // Default to all domains if undefined or empty array
+    const selectedDomains = !domains || domains.length === 0
+        ? exports.SEARCH_CRITERIA_DOMAINS.map((d) => d.name)
+        : domains;
+    // Validate that all specified domains exist
+    const validDomainNames = new Set(exports.SEARCH_CRITERIA_DOMAINS.map((d) => d.name));
+    const invalidDomains = selectedDomains.filter((d) => !validDomainNames.has(d));
+    if (invalidDomains.length > 0) {
+        throw new Error(`Invalid domain(s): ${invalidDomains.join(", ")}. Valid domains are: ${Array.from(validDomainNames).join(", ")}`);
+    }
+    return buildDomainDocumentation(selectedDomains, options || {});
+}
+/**
+ * Build complete system prompt for AI to generate SearchCriteria from natural language
+ * @param domains Optional domain names to include. If not specified, includes all domains.
+ *                Only domains that exist in SEARCH_CRITERIA_DOMAINS are allowed
+ * @param options Options for customizing the context (applies to all specified domains)
+ * @returns Complete system prompt string
+ * @example
+ * ```typescript
+ * // Full context with all domains
+ * const systemPrompt = buildSearchCriteriaSystemPrompt();
+ *
+ * // Selective context for specific domains
+ * const systemPrompt = buildSearchCriteriaSystemPrompt(["address", "building", "assessment"]);
+ *
+ * // All domains with options
+ * const systemPrompt = buildSearchCriteriaSystemPrompt(undefined, { maxFieldsPerDomain: 5 });
+ *
+ * // Specific domains with options
+ * const systemPrompt = buildSearchCriteriaSystemPrompt(["address", "building"], { maxFieldsPerDomain: 5 });
+ * ```
+ */
+function buildSearchCriteriaSystemPrompt(domains, options) {
+    // Build domain documentation using the unified function
+    const domainDocs = buildSearchCriteriaContext(domains, options);
+    return `You are an expert at creating property search criteria for real estate professionals. Your task is to convert natural language requests into structured BatchData.io search criteria.
+
+${domainDocs}
+
+FILTER TYPES:
+- StringFilter: { equals?, contains?, startsWith?, endsWith?, inList?, matches? }
+- NumericRangeFilter: { min?, max? }
+- DateRangeFilter: { minDate?, maxDate? }
+- GeoLocationDistance: { latitude, longitude, distanceMiles }
+- GeoLocationBoundingBox: { minLat, maxLat, minLon, maxLon }
+- GeoLocationPolygon: { geoPoints: [{ latitude, longitude }] }
+
+IMPORTANT RULES:
+1. Always include a "query" field with geographic scope (state, county, city, or "US")
+2. Use numeric ranges (min/max) for numeric filters like yearBuilt, bedroomCount, price, etc.
+3. Use string filters (equals, contains, inList) for text fields
+4. Be specific and realistic:
+   - "3 bedrooms" = building.bedroomCount: {min: 3, max: 3}
+   - "at least 3 bedrooms" = building.bedroomCount: {min: 3}
+   - "3-4 bedrooms" = building.bedroomCount: {min: 3, max: 4}
+   - "under $400,000" = assessment.totalMarketValue: {max: 400000}
+   - "over $500,000" = assessment.totalMarketValue: {min: 500000}
+   - "built after 2010" = building.yearBuilt: {min: 2010}
+5. Extract geographic information and populate both query and address filters appropriately
+6. Only include domains that are clearly relevant to the prompt
+7. If modifying existing criteria, merge intelligently - update what's mentioned, keep what's not
+
+Return your response as a JSON array. Each object should have:
+- searchCriteria: The complete SearchCriteria object
+- description: A natural language description of what this search criteria finds
+
+If the prompt suggests multiple distinct searches, return multiple objects. Otherwise, return a single object.`;
+}
+/**
+ * Get context documentation for a specific domain
+ * @param domainName The domain name (e.g., "address", "building", "assessment")
+ * @param options Options for customizing the context
+ * @returns Formatted documentation string for the domain
+ * @example
+ * ```typescript
+ * const addressContext = getDomainContext("address");
+ * // Returns formatted documentation for all address fields
+ * ```
+ */
+function getDomainContext(domainName, options = {}) {
+    const { maxFieldsPerDomain, maxExamplesPerField } = options;
+    // Find the domain
+    const domain = exports.SEARCH_CRITERIA_DOMAINS.find((d) => d.name === domainName);
+    if (!domain) {
+        return `Domain "${domainName}" not found.`;
+    }
+    // Build fields documentation
+    const fields = [];
+    if (domain.responseGroup) {
+        // Get filter contexts for this domain
+        const filterContexts = (0, search_criteria_filter_context_1.getDomainFilterContexts)(domain.responseGroup);
+        // Apply limits if specified
+        const limitedContexts = maxFieldsPerDomain
+            ? filterContexts.slice(0, maxFieldsPerDomain)
+            : filterContexts;
+        fields.push(...limitedContexts.map((context) => ({
+            name: context.searchCriteriaPath.split(".").pop() ||
+                context.searchCriteriaPath,
+            type: context.filterType,
+            description: context.description,
+            filterGuidance: context.filterGuidance,
+            examples: maxExamplesPerField
+                ? context.examples.slice(0, maxExamplesPerField)
+                : context.examples,
+        })));
+    }
+    // Build the documentation string
+    let doc = `- ${domain.name}: ${domain.description}`;
+    if (fields.length > 0) {
+        doc += "\n  Available fields:\n";
+        for (const field of fields) {
+            doc += `    - ${field.name} (${field.type}): ${field.description}\n`;
+            if (field.filterGuidance) {
+                doc += `      Filter: ${field.filterGuidance}\n`;
+            }
+            if (field.examples && field.examples.length > 0) {
+                doc += `      Examples: ${field.examples.join(", ")}\n`;
+            }
+        }
+    }
+    return doc;
+}
+/**
+ * Build domain documentation string for specified domains
+ * @param domainNames Array of domain names to include
+ * @param options Options for customizing the context
+ */
+function buildDomainDocumentation(domainNames, options = {}) {
+    const { maxFieldsPerDomain, maxExamplesPerField } = options;
+    // Filter domains to only include specified ones
+    const selectedDomains = exports.SEARCH_CRITERIA_DOMAINS.filter((domain) => domainNames.includes(domain.name));
+    // Ensure query is always first if included
+    const queryDomain = selectedDomains.find((d) => d.name === "query");
+    const otherDomains = selectedDomains.filter((d) => d.name !== "query");
+    const orderedDomains = queryDomain
+        ? [queryDomain, ...otherDomains]
+        : otherDomains;
+    const domains = orderedDomains.map((domain) => ({
+        ...domain,
+        fields: [],
+    }));
+    // Populate fields from metadata and filter context for each domain
+    for (const domain of domains) {
+        if (domain.responseGroup) {
+            // Get filter contexts for this domain (includes filter type and examples)
+            const filterContexts = (0, search_criteria_filter_context_1.getDomainFilterContexts)(domain.responseGroup);
+            // Apply limits if specified
+            const limitedContexts = maxFieldsPerDomain
+                ? filterContexts.slice(0, maxFieldsPerDomain)
+                : filterContexts;
+            domain.fields = limitedContexts.map((context) => ({
+                name: context.searchCriteriaPath.split(".").pop() ||
+                    context.searchCriteriaPath,
+                type: context.filterType,
+                description: context.description,
+                filterGuidance: context.filterGuidance,
+                examples: maxExamplesPerField
+                    ? context.examples.slice(0, maxExamplesPerField)
+                    : context.examples,
+            }));
+        }
+    }
+    // Build the documentation string
+    let doc = "";
+    const queryDomainItem = domains.find((d) => d.name === "query");
+    const optionalDomains = domains.filter((d) => d.name !== "query");
+    if (queryDomainItem) {
+        doc += "REQUIRED:\n";
+        doc += `- query: ${queryDomainItem.description}\n`;
+        if (optionalDomains.length > 0) {
+            doc += "\nOPTIONAL DOMAINS:\n";
+        }
+    }
+    else if (optionalDomains.length > 0) {
+        doc += "OPTIONAL DOMAINS:\n";
+    }
+    for (const domain of optionalDomains) {
+        doc += `\n- ${domain.name}: ${domain.description}`;
+        if (domain.fields.length > 0) {
+            doc += "\n  Available fields:\n";
+            for (const field of domain.fields) {
+                doc += `    - ${field.name} (${field.type}): ${field.description}\n`;
+                if (field.filterGuidance) {
+                    doc += `      Filter: ${field.filterGuidance}\n`;
+                }
+                if (field.examples && field.examples.length > 0) {
+                    doc += `      Examples: ${field.examples.join(", ")}\n`;
+                }
+            }
+        }
+    }
+    return doc;
+}
+/**
+ * Build user prompt with existing criteria context
+ * @param userPrompt The user's natural language prompt
+ * @param existingCriteria Optional existing search criteria to modify
+ * @returns Formatted user prompt string
+ */
+function buildSearchCriteriaUserPrompt(userPrompt, existingCriteria) {
+    const basePrompt = `Example response format:
+[
+  {
+    "searchCriteria": {
+      "query": "Maricopa County, AZ",
+      "building": {
+        "bedroomCount": { "min": 3, "max": 3 },
+        "yearBuilt": { "min": 2000 }
+      },
+      "assessment": {
+        "totalMarketValue": { "max": 500000 }
+      }
+    },
+    "description": "3-bedroom homes built after 2000 in Maricopa County, Arizona, with a market value under $500,000"
+  }
+]
+
+${existingCriteria ? `\nEXISTING SEARCH CRITERIA TO MODIFY:\n${JSON.stringify(existingCriteria, null, 2)}\n\nModify the existing criteria based on the user's prompt. Merge intelligently - update fields mentioned in the prompt, preserve others.` : ""}
+
+USER PROMPT:
+${userPrompt}
+
+Return only valid JSON, no markdown formatting or code blocks.`;
+    return basePrompt;
+}

package/dist/property-field/search-criteria-filter-context.d.ts

@@ -0,0 +1,92 @@
+/**
+ * SearchCriteria Filter Context
+ *
+ * Provides context about how filters should work for each SearchCriteria field.
+ * This includes filter type information and usage guidance.
+ */
+import type { PropertyFieldMetadata } from "./metadata";
+/**
+ * Filter type for a SearchCriteria field
+ */
+export type SearchCriteriaFilterType = "StringFilter" | "NumericRangeFilter" | "DateRangeFilter" | "QuickListValue";
+/**
+ * Context about how a SearchCriteria field should be filtered
+ */
+export interface SearchCriteriaFilterContext {
+    /**
+     * The SearchCriteria field path (e.g., "address.city", "building.yearBuilt")
+     */
+    searchCriteriaPath: string;
+    /**
+     * The type of filter to use (StringFilter, NumericRangeFilter, DateRangeFilter)
+     */
+    filterType: SearchCriteriaFilterType;
+    /**
+     * The corresponding Property field path, if any
+     */
+    propertyPath: string | undefined;
+    /**
+     * Property field metadata, if available
+     */
+    propertyMetadata: PropertyFieldMetadata | undefined;
+    /**
+     * Human-readable description of the field and how to filter it
+     */
+    description: string;
+    /**
+     * Example filter values or usage patterns
+     */
+    examples: string[];
+    /**
+     * Additional context about how this filter should be used
+     */
+    filterGuidance: string;
+}
+/**
+ * Get filter context for a SearchCriteria field path
+ * @param searchCriteriaPath The SearchCriteria field path (e.g., "address.city", "building.yearBuilt", "quickList")
+ * @returns Filter context including filter type, examples, and guidance
+ * @example
+ * ```typescript
+ * const context = getSearchCriteriaFilterContext("building.bedroomCount");
+ * console.log(context.filterType); // "NumericRangeFilter"
+ * console.log(context.examples); // ["{ min: 3, max: 3 } // exactly 3", ...]
+ * console.log(context.filterGuidance); // "Use NumericRangeFilter with: min, max..."
+ *
+ * const quickListContext = getSearchCriteriaFilterContext("quickList");
+ * console.log(quickListContext.filterType); // "QuickListValue"
+ * ```
+ */
+export declare function getSearchCriteriaFilterContext(searchCriteriaPath: string): SearchCriteriaFilterContext;
+/**
+ * Get a formatted string with complete filter context for a SearchCriteria field
+ * This is useful for generating documentation or AI prompts
+ * @param searchCriteriaPath The SearchCriteria field path
+ * @returns A formatted string with all filter context information
+ * @example
+ * ```typescript
+ * const contextString = getSearchCriteriaFilterContextString("building.bedroomCount");
+ * // Returns a formatted string with filter type, examples, and guidance
+ * ```
+ */
+export declare function getSearchCriteriaFilterContextString(searchCriteriaPath: string): string;
+/**
+ * Get filter context for all fields in a SearchCriteria domain/group
+ * @param domainName The domain name (e.g., "address", "building", "assessment", "quickList")
+ * @returns Array of filter contexts for all fields in that domain
+ * @example
+ * ```typescript
+ * const addressFields = getDomainFilterContexts("address");
+ * // Returns filter contexts for all address.* fields
+ *
+ * const quickListContexts = getDomainFilterContexts("quickList");
+ * // Returns contexts for quickList, quickLists, and orQuickLists
+ * ```
+ */
+export declare function getDomainFilterContexts(domainName: string): SearchCriteriaFilterContext[];
+/**
+ * Get a formatted documentation string for all fields in a domain
+ * @param domainName The domain name
+ * @returns A formatted string with filter context for all fields in the domain
+ */
+export declare function getDomainFilterContextDocumentation(domainName: string): string;

package/dist/property-field/search-criteria-filter-context.js

@@ -0,0 +1,550 @@
+"use strict";
+/**
+ * SearchCriteria Filter Context
+ *
+ * Provides context about how filters should work for each SearchCriteria field.
+ * This includes filter type information and usage guidance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSearchCriteriaFilterContext = getSearchCriteriaFilterContext;
+exports.getSearchCriteriaFilterContextString = getSearchCriteriaFilterContextString;
+exports.getDomainFilterContexts = getDomainFilterContexts;
+exports.getDomainFilterContextDocumentation = getDomainFilterContextDocumentation;
+const metadata_1 = require("./metadata");
+/**
+ * Mapping of SearchCriteria field paths to their filter types
+ * This is derived from the SearchCriteria type definitions
+ */
+const SEARCH_CRITERIA_FILTER_TYPE_MAP = {
+    // Address fields - StringFilter
+    "address.street": "StringFilter",
+    "address.city": "StringFilter",
+    "address.locality": "StringFilter",
+    "address.county": "StringFilter",
+    "address.countyFipsCode": "StringFilter",
+    "address.state": "StringFilter",
+    "address.zip": "StringFilter",
+    "address.unitType": "StringFilter",
+    "address.formattedStreet": "StringFilter",
+    "address.streetNoUnit": "StringFilter",
+    "address.initialGeoStatus": "StringFilter",
+    "address.geoStatus": "StringFilter",
+    "address.cityState": "StringFilter",
+    "address.countyState": "StringFilter",
+    // Assessment fields - NumericRangeFilter
+    "assessment.assessmentYear": "NumericRangeFilter",
+    "assessment.totalAssessedValue": "NumericRangeFilter",
+    "assessment.assessedImprovementValue": "NumericRangeFilter",
+    "assessment.assessedLandValue": "NumericRangeFilter",
+    "assessment.marketValueYear": "NumericRangeFilter",
+    "assessment.landMarketValue": "NumericRangeFilter",
+    "assessment.improvementMarketValue": "NumericRangeFilter",
+    "assessment.totalMarketValue": "NumericRangeFilter",
+    // Building fields - mix of StringFilter and NumericRangeFilter
+    "building.airConditioningSource": "StringFilter",
+    "building.basementType": "StringFilter",
+    "building.totalBuildingAreaSquareFeet": "NumericRangeFilter",
+    "building.buildingClass": "StringFilter",
+    "building.buildingCondition": "StringFilter",
+    "building.buildingQuality": "StringFilter",
+    "building.buildingType": "StringFilter",
+    "building.driveway": "StringFilter",
+    "building.exteriorWalls": "StringFilter",
+    "building.floorCover": "StringFilter",
+    "building.garageParkingSpaceCount": "NumericRangeFilter",
+    "building.garage": "StringFilter",
+    "building.heatSource": "StringFilter",
+    "building.heatingFuelType": "StringFilter",
+    "building.interiorWalls": "StringFilter",
+    "building.buildingCount": "NumericRangeFilter",
+    "building.bathroomCount": "NumericRangeFilter",
+    "building.calculatedBathroomCount": "NumericRangeFilter",
+    "building.bedroomCount": "NumericRangeFilter",
+    "building.patio": "StringFilter",
+    "building.storyCount": "NumericRangeFilter",
+    "building.features": "StringFilter",
+    "building.residentialUnitCount": "NumericRangeFilter",
+    "building.pool": "StringFilter",
+    "building.porch": "StringFilter",
+    "building.roofCover": "StringFilter",
+    "building.roofType": "StringFilter",
+    "building.sewer": "StringFilter",
+    "building.style": "StringFilter",
+    "building.roomCount": "NumericRangeFilter",
+    "building.unitCount": "NumericRangeFilter",
+    "building.constructionType": "StringFilter",
+    "building.waterService": "StringFilter",
+    "building.yearBuilt": "NumericRangeFilter",
+    // Demographics - mix
+    "demographics.age": "NumericRangeFilter",
+    "demographics.householdSize": "NumericRangeFilter",
+    "demographics.income": "NumericRangeFilter",
+    "demographics.netWorth": "NumericRangeFilter",
+    "demographics.discretionaryIncome": "NumericRangeFilter",
+    "demographics.homeownerRenter": "StringFilter",
+    "demographics.businessOwner": "StringFilter",
+    "demographics.gender": "StringFilter",
+    "demographics.investments": "StringFilter",
+    "demographics.demographics": "StringFilter",
+    "demographics.religiousAffiliation": "StringFilter",
+    // Foreclosure - mix
+    "foreclosure.status": "StringFilter",
+    "foreclosure.recordingDate": "DateRangeFilter",
+    "foreclosure.auctionDate": "DateRangeFilter",
+    "foreclosure.releaseDate": "DateRangeFilter",
+    "foreclosure.auctionMinimumBidAmount": "NumericRangeFilter",
+    "foreclosure.pastDueAmount": "NumericRangeFilter",
+    // General - StringFilter
+    "general.propertyTypeCategory": "StringFilter",
+    "general.propertyTypeDetail": "StringFilter",
+    // IDs - StringFilter
+    "ids.addressHash": "StringFilter",
+    "ids.mailingAddressHash": "StringFilter",
+    "ids.fipsCode": "StringFilter",
+    "ids.apn": "StringFilter",
+    "ids.taxId": "StringFilter",
+    // Intel - mix
+    "intel.lastSoldDate": "DateRangeFilter",
+    "intel.lastSoldPrice": "NumericRangeFilter",
+    "intel.salePropensity": "NumericRangeFilter",
+    // Involuntary Lien - mix
+    "involuntaryLien.lienType": "StringFilter",
+    "involuntaryLien.lienTypeCode": "StringFilter",
+    "involuntaryLien.documentType": "StringFilter",
+    "involuntaryLien.documentTypeCode": "StringFilter",
+    "involuntaryLien.recordingDate": "DateRangeFilter",
+    "involuntaryLien.filingDate": "DateRangeFilter",
+    "involuntaryLien.lienAmount": "NumericRangeFilter",
+    // Legal - StringFilter
+    "legal.subdivisionName": "StringFilter",
+    // Listing - mix
+    "listing.description": "StringFilter",
+    "listing.price": "NumericRangeFilter",
+    "listing.daysOnMarket": "NumericRangeFilter",
+    "listing.status": "StringFilter",
+    "listing.statusCategory": "StringFilter",
+    "listing.failedListingDate": "DateRangeFilter",
+    "listing.soldDate": "DateRangeFilter",
+    // Lot - mix
+    "lot.lotSizeAcres": "NumericRangeFilter",
+    "lot.lotDepthFeet": "NumericRangeFilter",
+    "lot.lotFrontageFeet": "NumericRangeFilter",
+    "lot.lotSizeSquareFeet": "NumericRangeFilter",
+    "lot.zoningCode": "StringFilter",
+    // Open Lien - mix
+    "openLien.allLoanTypes": "StringFilter",
+    "openLien.juniorLoanTypes": "StringFilter",
+    "openLien.totalOpenLienCount": "NumericRangeFilter",
+    "openLien.totalOpenLienBalance": "NumericRangeFilter",
+    "openLien.firstLoanLtv": "NumericRangeFilter",
+    "openLien.firstLoanInterestRate": "NumericRangeFilter",
+    "openLien.secondLoanInterestRate": "NumericRangeFilter",
+    "openLien.thirdLoanInterestRate": "NumericRangeFilter",
+    "openLien.fourthLoanInterestRate": "NumericRangeFilter",
+    "openLien.firstLoanType": "StringFilter",
+    "openLien.secondLoanType": "StringFilter",
+    "openLien.thirdLoanType": "StringFilter",
+    "openLien.fourthLoanType": "StringFilter",
+    "openLien.firstLoanRecordingDate": "DateRangeFilter",
+    "openLien.lastLoanRecordingDate": "DateRangeFilter",
+    // Owner - mix
+    "owner.firstName": "StringFilter",
+    "owner.lastName": "StringFilter",
+    "owner.mailingStreet": "StringFilter",
+    "owner.mailingCity": "StringFilter",
+    "owner.mailingState": "StringFilter",
+    "owner.mailingZip": "StringFilter",
+    "owner.ownerStatusType": "StringFilter",
+    "owner.lengthOfResidenceMonths": "NumericRangeFilter",
+    "owner.lengthOfResidenceYears": "NumericRangeFilter",
+    "owner.ownershipStartDate": "DateRangeFilter",
+    "owner.mailingAddressHash": "StringFilter",
+    // Permit - mix
+    "permit.permitCount": "NumericRangeFilter",
+    "permit.latestDate": "DateRangeFilter",
+    "permit.earliestDate": "DateRangeFilter",
+    "permit.totalJobValue": "NumericRangeFilter",
+    "permit.allTags": "StringFilter",
+    // Property Owner Profile - NumericRangeFilter
+    "propertyOwnerProfile.propertiesCount": "NumericRangeFilter",
+    "propertyOwnerProfile.propertiesTotalEquity": "NumericRangeFilter",
+    "propertyOwnerProfile.propertiesTotalEstimatedValue": "NumericRangeFilter",
+    "propertyOwnerProfile.mortgagesTotalBalance": "NumericRangeFilter",
+    "propertyOwnerProfile.mortgagesCount": "NumericRangeFilter",
+    "propertyOwnerProfile.mortgagesAverageBalance": "NumericRangeFilter",
+    // Sale - mix
+    "sale.lastSalePrice": "NumericRangeFilter",
+    "sale.lastSaleDate": "DateRangeFilter",
+    "sale.lastSaleDocumentType": "StringFilter",
+    "sale.lastSalePricePerSquareFoot": "NumericRangeFilter",
+    "sale.flipLength": "NumericRangeFilter",
+    "sale.flipLengthCategory": "NumericRangeFilter",
+    "sale.flipProfit": "NumericRangeFilter",
+    // Tax - NumericRangeFilter
+    "tax.taxDelinquentYear": "NumericRangeFilter",
+    // Valuation - NumericRangeFilter
+    "valuation.estimatedValue": "NumericRangeFilter",
+    "valuation.ltv": "NumericRangeFilter",
+    "valuation.equityPercent": "NumericRangeFilter",
+};
+/**
+ * Get filter guidance text based on filter type
+ */
+function getFilterGuidance(filterType) {
+    switch (filterType) {
+        case "StringFilter":
+            return `Use StringFilter with: equals (exact match), contains (substring), startsWith, endsWith, inList (array of values), or matches (regex). Example: { equals: "Phoenix" } or { inList: ["Phoenix", "Tucson"] }`;
+        case "NumericRangeFilter":
+            return `Use NumericRangeFilter with: min (minimum value), max (maximum value), or both. Example: { min: 3, max: 5 } for "3-5 bedrooms" or { min: 2010 } for "built after 2010"`;
+        case "DateRangeFilter":
+            return `Use DateRangeFilter with: minDate (earliest date), maxDate (latest date), or both. Dates should be in ISO 8601 format (YYYY-MM-DD). Example: { minDate: "2020-01-01" } for "after 2020"`;
+        case "QuickListValue":
+            return `Use a QuickListValue string. Can be prefixed with "not-" to exclude. Available as: quickList (single value), quickLists (array), orQuickLists (array for OR logic). Example: "owner-occupied" or "not-vacant"`;
+        default:
+            return "Unknown filter type";
+    }
+}
+/**
+ * Get example values based on field and filter type
+ */
+function getExamples(fieldPath, filterType, _propertyMetadata) {
+    const examples = [];
+    switch (filterType) {
+        case "StringFilter":
+            if (fieldPath.includes("city")) {
+                examples.push('{ equals: "Phoenix" }');
+                examples.push('{ inList: ["Phoenix", "Tucson", "Mesa"] }');
+            }
+            else if (fieldPath.includes("state")) {
+                examples.push('{ equals: "AZ" }');
+            }
+            else if (fieldPath.includes("status")) {
+                examples.push('{ equals: "active" }');
+            }
+            else {
+                examples.push('{ equals: "value" }');
+                examples.push('{ contains: "substring" }');
+            }
+            break;
+        case "NumericRangeFilter":
+            if (fieldPath.includes("bedroom") || fieldPath.includes("bathroom")) {
+                examples.push("{ min: 3, max: 3 } // exactly 3");
+                examples.push("{ min: 3 } // at least 3");
+                examples.push("{ min: 3, max: 5 } // between 3 and 5");
+            }
+            else if (fieldPath.includes("yearBuilt")) {
+                examples.push("{ min: 2010 } // built after 2010");
+                examples.push("{ max: 2000 } // built before 2000");
+            }
+            else if (fieldPath.includes("Value") || fieldPath.includes("Price")) {
+                examples.push("{ max: 400000 } // under $400,000");
+                examples.push("{ min: 500000 } // over $500,000");
+                examples.push("{ min: 300000, max: 500000 } // between $300k and $500k");
+            }
+            else {
+                examples.push("{ min: 0 }");
+                examples.push("{ max: 100 }");
+                examples.push("{ min: 10, max: 50 }");
+            }
+            break;
+        case "DateRangeFilter":
+            examples.push('{ minDate: "2020-01-01" } // after January 1, 2020');
+            examples.push('{ maxDate: "2023-12-31" } // before December 31, 2023');
+            examples.push('{ minDate: "2020-01-01", maxDate: "2023-12-31" } // between dates');
+            break;
+    }
+    return examples;
+}
+/**
+ * Valid QuickList values with descriptions (from core/types.ts and metadata)
+ */
+const QUICK_LIST_VALUES_WITH_DESCRIPTIONS = [
+    {
+        value: "absentee-owner",
+        description: "Property owner does not reside at the property",
+    },
+    {
+        value: "active-auction",
+        description: "Property has an auction date greater than the current date",
+    },
+    {
+        value: "active-listing",
+        description: "Property has an active listing",
+    },
+    {
+        value: "canceled-listing",
+        description: "Property has a canceled listing",
+    },
+    {
+        value: "cash-buyer",
+        description: "Property was purchased with cash",
+    },
+    {
+        value: "corporate-owned",
+        description: "Property is owned by a corporate entity (i.e., not an individual)",
+    },
+    {
+        value: "expired-listing",
+        description: "Property has an expired listing",
+    },
+    {
+        value: "failed-listing",
+        description: "The listing was either cancelled or expired and not sold",
+    },
+    {
+        value: "fix-and-flip",
+        description: "Property has been bought and sold in the last 12 months",
+    },
+    {
+        value: "free-and-clear",
+        description: "Property is free of any mortgage",
+    },
+    {
+        value: "for-sale-by-owner",
+        description: "Property is listed for sale by the owner",
+    },
+    {
+        value: "has-hoa",
+        description: "Property is part of a homeowner association",
+    },
+    {
+        value: "has-hoa-fees",
+        description: "Property has homeowner association fees",
+    },
+    {
+        value: "high-equity",
+        description: "Property owner has more than 20% equity in the property",
+    },
+    {
+        value: "inherited",
+        description: "Property owner has inherited the property",
+    },
+    {
+        value: "involuntary-lien",
+        description: "Property has an involuntary lien recorded against it, indicating a legal claim due to unpaid debts or obligations",
+    },
+    {
+        value: "in-state-absentee-owner",
+        description: "Property owner does not reside at the property, and the property address and owner mailing address are in the same state",
+    },
+    {
+        value: "listed-below-market-price",
+        description: "Property is listed below market price",
+    },
+    {
+        value: "low-equity",
+        description: "Property owner has less than 20% equity in the property",
+    },
+    {
+        value: "mailing-address-vacant",
+        description: "Property mailing address is vacant",
+    },
+    {
+        value: "notice-of-default",
+        description: "Property has a default of a loan by the borrower of the mortgage",
+    },
+    {
+        value: "notice-of-lis-pendens",
+        description: "Property has a pending lawsuit",
+    },
+    {
+        value: "notice-of-sale",
+        description: "Property has received a notice of sale",
+    },
+    {
+        value: "on-market",
+        description: "Property is available for sale",
+    },
+    {
+        value: "out-of-state-absentee-owner",
+        description: "Property owner does not reside at the property, and the property address and owner mailing address are in different states",
+    },
+    {
+        value: "out-of-state-owner",
+        description: "Property owner resides out of state",
+    },
+    {
+        value: "owner-occupied",
+        description: "Property is occupied by the owner",
+    },
+    {
+        value: "pending-listing",
+        description: "Property listing is pending (not yet active)",
+    },
+    {
+        value: "preforeclosure",
+        description: "Property is in pre-foreclosure",
+    },
+    {
+        value: "recently-sold",
+        description: "Property was sold in the last 12 months",
+    },
+    {
+        value: "same-property-and-mailing-address",
+        description: "Property address is the same as the mailing address",
+    },
+    {
+        value: "tax-default",
+        description: "Property is in tax default and the first tax default was at least three years ago",
+    },
+    {
+        value: "tired-landlord",
+        description: "Property is a single family residence owned for at least 10 years",
+    },
+    {
+        value: "unknown-equity",
+        description: "Property equity is unknown",
+    },
+    {
+        value: "vacant",
+        description: "USPS has flagged the property as vacant",
+    },
+    {
+        value: "vacant-lot",
+        description: "Property is likely to be a vacant lot",
+    },
+    {
+        value: "senior-owner",
+        description: "An individual property owner who resides in the property for 25 or more years, has senior tax exemption, or currently holds an open reverse mortgage",
+    },
+    {
+        value: "trust-owned",
+        description: "Property is owned by a trust",
+    },
+];
+/**
+ * Get filter context for a SearchCriteria field path
+ * @param searchCriteriaPath The SearchCriteria field path (e.g., "address.city", "building.yearBuilt", "quickList")
+ * @returns Filter context including filter type, examples, and guidance
+ * @example
+ * ```typescript
+ * const context = getSearchCriteriaFilterContext("building.bedroomCount");
+ * console.log(context.filterType); // "NumericRangeFilter"
+ * console.log(context.examples); // ["{ min: 3, max: 3 } // exactly 3", ...]
+ * console.log(context.filterGuidance); // "Use NumericRangeFilter with: min, max..."
+ *
+ * const quickListContext = getSearchCriteriaFilterContext("quickList");
+ * console.log(quickListContext.filterType); // "QuickListValue"
+ * ```
+ */
+function getSearchCriteriaFilterContext(searchCriteriaPath) {
+    // Handle special quickList fields
+    if (searchCriteriaPath === "quickList" ||
+        searchCriteriaPath === "quickLists" ||
+        searchCriteriaPath === "orQuickLists") {
+        return {
+            searchCriteriaPath,
+            filterType: "QuickListValue",
+            propertyPath: undefined,
+            propertyMetadata: undefined,
+            description: `Pre-defined quick filter${searchCriteriaPath === "quickList" ? "" : "s"} for common property characteristics. Values can be prefixed with "not-" to exclude (e.g., "not-vacant" excludes vacant properties). Use ${searchCriteriaPath === "orQuickLists" ? "orQuickLists array for OR logic" : searchCriteriaPath === "quickLists" ? "quickLists array for multiple values" : "quickList for a single value"}.`,
+            examples: [
+                ...QUICK_LIST_VALUES_WITH_DESCRIPTIONS.slice(0, 5).map((item) => `"${item.value}" // ${item.description}`),
+                '"not-vacant" // Exclude vacant properties',
+                '"not-owner-occupied" // Exclude owner-occupied properties',
+                `\nAll available QuickList values (${QUICK_LIST_VALUES_WITH_DESCRIPTIONS.length} total):\n${QUICK_LIST_VALUES_WITH_DESCRIPTIONS.map((item) => `  - "${item.value}": ${item.description}`).join("\n")}`,
+            ],
+            filterGuidance: getFilterGuidance("QuickListValue"),
+        };
+    }
+    const filterType = SEARCH_CRITERIA_FILTER_TYPE_MAP[searchCriteriaPath] || "StringFilter";
+    // Try to get Property field metadata
+    const propertyMetadata = (0, metadata_1.getFieldMetadata)(searchCriteriaPath);
+    const propertyPath = propertyMetadata ? searchCriteriaPath : undefined;
+    // Build description
+    let description;
+    if (propertyMetadata) {
+        description = `Filter on ${propertyMetadata.description}`;
+    }
+    else {
+        const parts = searchCriteriaPath.split(".");
+        const fieldName = parts[parts.length - 1] || searchCriteriaPath;
+        description = `Filter on ${fieldName} field`;
+    }
+    // Get examples and guidance
+    const examples = getExamples(searchCriteriaPath, filterType, propertyMetadata);
+    const filterGuidance = getFilterGuidance(filterType);
+    return {
+        searchCriteriaPath,
+        filterType,
+        propertyPath,
+        propertyMetadata: propertyMetadata || undefined,
+        description,
+        examples,
+        filterGuidance,
+    };
+}
+/**
+ * Get a formatted string with complete filter context for a SearchCriteria field
+ * This is useful for generating documentation or AI prompts
+ * @param searchCriteriaPath The SearchCriteria field path
+ * @returns A formatted string with all filter context information
+ * @example
+ * ```typescript
+ * const contextString = getSearchCriteriaFilterContextString("building.bedroomCount");
+ * // Returns a formatted string with filter type, examples, and guidance
+ * ```
+ */
+function getSearchCriteriaFilterContextString(searchCriteriaPath) {
+    const context = getSearchCriteriaFilterContext(searchCriteriaPath);
+    const parts = [];
+    parts.push(`Field: ${context.searchCriteriaPath}`);
+    parts.push(`Filter Type: ${context.filterType}`);
+    parts.push(`Description: ${context.description}`);
+    if (context.propertyMetadata) {
+        parts.push(`Property Field: ${context.propertyPath} (${context.propertyMetadata.dataType})`);
+    }
+    parts.push(`\nFilter Guidance:\n${context.filterGuidance}`);
+    if (context.examples.length > 0) {
+        parts.push(`\nExamples:`);
+        context.examples.forEach((example) => {
+            parts.push(`  ${example}`);
+        });
+    }
+    return parts.join("\n");
+}
+/**
+ * Get filter context for all fields in a SearchCriteria domain/group
+ * @param domainName The domain name (e.g., "address", "building", "assessment", "quickList")
+ * @returns Array of filter contexts for all fields in that domain
+ * @example
+ * ```typescript
+ * const addressFields = getDomainFilterContexts("address");
+ * // Returns filter contexts for all address.* fields
+ *
+ * const quickListContexts = getDomainFilterContexts("quickList");
+ * // Returns contexts for quickList, quickLists, and orQuickLists
+ * ```
+ */
+function getDomainFilterContexts(domainName) {
+    const contexts = [];
+    // Handle special quickList domain
+    if (domainName === "quickList") {
+        contexts.push(getSearchCriteriaFilterContext("quickList"));
+        contexts.push(getSearchCriteriaFilterContext("quickLists"));
+        contexts.push(getSearchCriteriaFilterContext("orQuickLists"));
+        return contexts;
+    }
+    // Find all fields that start with the domain name
+    for (const fieldPath in SEARCH_CRITERIA_FILTER_TYPE_MAP) {
+        if (fieldPath.startsWith(`${domainName}.`)) {
+            contexts.push(getSearchCriteriaFilterContext(fieldPath));
+        }
+    }
+    return contexts.sort((a, b) => a.searchCriteriaPath.localeCompare(b.searchCriteriaPath));
+}
+/**
+ * Get a formatted documentation string for all fields in a domain
+ * @param domainName The domain name
+ * @returns A formatted string with filter context for all fields in the domain
+ */
+function getDomainFilterContextDocumentation(domainName) {
+    const contexts = getDomainFilterContexts(domainName);
+    const parts = [];
+    parts.push(`\n${domainName.toUpperCase()} DOMAIN:`);
+    parts.push("=".repeat(50));
+    for (const context of contexts) {
+        parts.push(`\n${getSearchCriteriaFilterContextString(context.searchCriteriaPath)}`);
+    }
+    return parts.join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@land-catalyst/batch-data-sdk",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "TypeScript SDK for BatchData.io Property API - Types, Builders, and Utilities",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",