@urbankitstudio/atlas 0.6.30 → 0.6.31

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (45) hide show
  1. package/README.md +56 -1
  2. package/data/city-property/atlanta.json +42 -0
  3. package/data/city-property/austin.json +61 -0
  4. package/data/city-property/boston.json +62 -0
  5. package/data/city-property/charlotte.json +40 -0
  6. package/data/city-property/chicago.json +61 -0
  7. package/data/city-property/columbus.json +65 -0
  8. package/data/city-property/dallas.json +61 -0
  9. package/data/city-property/denver.json +38 -0
  10. package/data/city-property/detroit.json +58 -0
  11. package/data/city-property/index.json +266 -0
  12. package/data/city-property/kansas-city.json +64 -0
  13. package/data/city-property/las-vegas.json +57 -0
  14. package/data/city-property/milwaukee.json +37 -0
  15. package/data/city-property/nashville.json +61 -0
  16. package/data/city-property/nyc.json +63 -0
  17. package/data/city-property/philadelphia.json +62 -0
  18. package/data/city-property/phoenix.json +41 -0
  19. package/data/city-property/san-antonio.json +56 -0
  20. package/data/city-property/san-francisco.json +60 -0
  21. package/data/city-property/seattle.json +63 -0
  22. package/data/city-property/washington-dc.json +37 -0
  23. package/data/city-zoning/atlanta.json +49 -0
  24. package/data/city-zoning/austin.json +114 -0
  25. package/data/city-zoning/boise.json +41 -0
  26. package/data/city-zoning/boston.json +51 -0
  27. package/data/city-zoning/charlotte.json +42 -0
  28. package/data/city-zoning/dallas.json +33 -0
  29. package/data/city-zoning/denver.json +45 -0
  30. package/data/city-zoning/durham.json +39 -0
  31. package/data/city-zoning/fort-worth.json +44 -0
  32. package/data/city-zoning/index.json +174 -0
  33. package/data/city-zoning/indianapolis.json +50 -0
  34. package/data/city-zoning/los-angeles.json +32 -0
  35. package/data/city-zoning/nashville.json +45 -0
  36. package/data/city-zoning/new-orleans.json +49 -0
  37. package/data/city-zoning/nyc.json +53 -0
  38. package/data/city-zoning/raleigh.json +45 -0
  39. package/data/city-zoning/tampa.json +40 -0
  40. package/data/city-zoning/washington-dc.json +42 -0
  41. package/dist/index.cjs +3055 -0
  42. package/dist/index.d.cts +449 -1
  43. package/dist/index.d.ts +449 -1
  44. package/dist/index.js +3032 -1
  45. package/package.json +10 -3
package/dist/index.d.ts CHANGED
@@ -401,4 +401,452 @@ interface Atlas {
401
401
  }
402
402
  declare const atlas: Atlas;
403
403
 
404
- export { type Atlas, type AtlasIndex, type CapabilityBasis, type CapabilityBasisType, type CapabilityField, type CapabilityOverrides, type CapabilityStatus, type ContactInfo, type CountyAdvisory, type CountyRecord, type DeepLinkCounty, type EndpointRecord, type EndpointStatus, LIVE_STATUS_URL, type LicenseType, type SearchField, type ServiceType, type StateFile, type StateIndexEntry, type VerifiedBy, atlas, atlasIndex, buildParcelLookupDeepLink, canonicalLayerUrl, countyOffersAttributeSearch, countyPath, countySlugFromName, findCounty, findCountyByFips, findState, isReviewedUnservable, listCountiesByState, listStates, offersAttributeSearch, offersPagination, reviewedCapability, slugify, statePath };
404
+ type PropertySourceType = "socrata" | "arcgis" | "ckan" | "carto";
405
+ /**
406
+ * Canonical field names the site's Property Report renders. A city's source
407
+ * response is mapped onto these by the per-dataset field map, so no provider's
408
+ * column names are hard-coded anywhere. `address` is the column searched.
409
+ */
410
+ interface PropertyFieldMap {
411
+ address: string;
412
+ /** Ordered columns composed into the display address when the table splits the street. */
413
+ addressParts?: string[];
414
+ /**
415
+ * Column holding the street NUMBER on its own. When set, a typed "number
416
+ * name" street is matched as `address LIKE %name% AND streetNumber = number`;
417
+ * unset, the search is the plain substring match.
418
+ */
419
+ streetNumber?: string;
420
+ recordNumber?: string;
421
+ type?: string;
422
+ description?: string;
423
+ status?: string;
424
+ contractor?: string;
425
+ value?: string;
426
+ openedDate?: string;
427
+ closedDate?: string;
428
+ zip?: string;
429
+ link?: string;
430
+ }
431
+ interface PropertyStatusBuckets {
432
+ active?: string[];
433
+ closed?: string[];
434
+ }
435
+ type DatasetKind = "violations" | "permits";
436
+ interface PropertyDataset {
437
+ kind: DatasetKind;
438
+ tabLabel: string;
439
+ type: PropertySourceType;
440
+ /**
441
+ * Socrata: the resource .json URL. ArcGIS: the layer URL (.../FeatureServer/0).
442
+ * CKAN: the portal base URL; resourceId names the datastore resource. CARTO:
443
+ * the SQL-API host; resourceId names the table.
444
+ */
445
+ url: string;
446
+ resourceId?: string;
447
+ /** Column to sort by newest-first server-side. Absent for text dates that cannot sort. */
448
+ orderField?: string;
449
+ /** Extra filter ANDed into every query (SoQL, SQL, or an ArcGIS WHERE expression). */
450
+ where?: string;
451
+ /** How the streetNumber column is typed at the source. Default "text". */
452
+ streetNumberType?: "text" | "number";
453
+ /** The newest value of the date column seen at the last verification (YYYY-MM-DD). */
454
+ latestRecordDate?: string;
455
+ /** One sober line stating the time span the dataset actually covers. */
456
+ coverage: string;
457
+ recordLabel?: string;
458
+ openedLabel?: string;
459
+ closedLabel?: string;
460
+ fields: PropertyFieldMap;
461
+ statusBuckets?: PropertyStatusBuckets;
462
+ }
463
+ interface PropertyDatasets {
464
+ violations?: PropertyDataset;
465
+ permits?: PropertyDataset;
466
+ }
467
+ interface PropertySource {
468
+ name: string;
469
+ url: string;
470
+ license?: string;
471
+ portalLabel?: string;
472
+ currentRecordsNote?: string;
473
+ currentRecordsUrl?: string;
474
+ }
475
+ interface CityPropertyRecord {
476
+ slug: string;
477
+ city: string;
478
+ state: string;
479
+ stateAbbrev: string;
480
+ countyName?: string;
481
+ countySlug?: string;
482
+ lastVerified: string;
483
+ /** Clarifies the data is city-scoped, not county-wide. */
484
+ scopeNote?: string;
485
+ datasets: PropertyDatasets;
486
+ source: PropertySource;
487
+ }
488
+ interface CityPropertyIndexEntry {
489
+ slug: string;
490
+ city: string;
491
+ state: string;
492
+ stateAbbrev: string;
493
+ populated: boolean;
494
+ provider: string;
495
+ countyName?: string;
496
+ countySlug?: string;
497
+ /** The dataset kinds the city's file declares. */
498
+ datasets?: DatasetKind[];
499
+ note?: string;
500
+ }
501
+ interface CityPropertyIndex {
502
+ lastUpdated: string;
503
+ cities: CityPropertyIndexEntry[];
504
+ }
505
+ type ZoningSourceType = "socrata" | "arcgis";
506
+ /**
507
+ * "cases": an address-searchable rezoning case log. "current-zoning": no case
508
+ * log is published, but the current zoning map is; the lookup geocodes the
509
+ * address and intersects the base-zoning layer.
510
+ */
511
+ type ZoningToolKind = "cases" | "current-zoning";
512
+ interface CaseFieldMap {
513
+ caseNumber?: string;
514
+ caseName?: string;
515
+ /** The address text column. Required for address lookups; absent for polygon-only dockets. */
516
+ address?: string;
517
+ addressParts?: string[];
518
+ caseType?: string;
519
+ status?: string;
520
+ proposedZoning?: string;
521
+ existingZoning?: string;
522
+ proposedLandUse?: string;
523
+ existingLandUse?: string;
524
+ ownerName?: string;
525
+ ownerOrg?: string;
526
+ appliedDate?: string;
527
+ statusDate?: string;
528
+ district?: string;
529
+ link?: string;
530
+ }
531
+ interface ZoningStatusBuckets {
532
+ active?: string[];
533
+ approved?: string[];
534
+ closed?: string[];
535
+ }
536
+ interface CasesSource {
537
+ type: ZoningSourceType;
538
+ url: string;
539
+ orderField?: string;
540
+ fields: CaseFieldMap;
541
+ /**
542
+ * "address" (default): LIKE on the mapped address column. "location":
543
+ * geocode to a point and let the server answer point-in-polygon. "parcel":
544
+ * resolve the address to a parcel id, join through a crosswalk dataset.
545
+ */
546
+ lookup?: "address" | "location" | "parcel";
547
+ geocoder?: GeocoderConfig;
548
+ resolver?: {
549
+ provider: "nyc-geosearch";
550
+ };
551
+ crosswalk?: {
552
+ url: string;
553
+ parcelField: string;
554
+ projectField: string;
555
+ };
556
+ joinField?: string;
557
+ /** What this docket honestly is ("zoning and rezoning cases" by default). */
558
+ caseLabel?: string;
559
+ where?: string;
560
+ nullSentinels?: string[];
561
+ statusBuckets?: ZoningStatusBuckets;
562
+ /** The newest value of the date column seen at the last verification (YYYY-MM-DD). */
563
+ latestRecordDate?: string;
564
+ }
565
+ interface ZoningByAddressSource {
566
+ type: ZoningSourceType;
567
+ url: string;
568
+ fields: {
569
+ address: string;
570
+ baseZone: string;
571
+ baseZoneCategory?: string;
572
+ zoneType?: string;
573
+ };
574
+ }
575
+ type GeocoderProvider = "nominatim" | "census";
576
+ interface GeocoderConfig {
577
+ provider: GeocoderProvider;
578
+ context: string;
579
+ }
580
+ interface CurrentZoningFieldMap {
581
+ zoneDist: string;
582
+ longZoneDist?: string;
583
+ pdNum?: string;
584
+ caseNumber?: string;
585
+ effectiveDate?: string;
586
+ districtUse?: string;
587
+ }
588
+ interface CurrentZoningSource {
589
+ type: "arcgis";
590
+ url: string;
591
+ geocoder: GeocoderConfig;
592
+ fields: CurrentZoningFieldMap;
593
+ }
594
+ interface CitySource {
595
+ name: string;
596
+ url: string;
597
+ datasetUrl?: string;
598
+ license?: string;
599
+ portalLabel?: string;
600
+ }
601
+ interface CityZoningRecord {
602
+ slug: string;
603
+ city: string;
604
+ state: string;
605
+ stateAbbrev: string;
606
+ countyName?: string;
607
+ countySlug?: string;
608
+ lastVerified: string;
609
+ /** Absent means "cases". */
610
+ kind?: ZoningToolKind;
611
+ cases?: CasesSource;
612
+ currentZoning?: CurrentZoningSource;
613
+ zoningByAddress?: ZoningByAddressSource;
614
+ zoneGlossary?: Record<string, string>;
615
+ source: CitySource;
616
+ }
617
+ interface CityZoningIndexEntry {
618
+ slug: string;
619
+ city: string;
620
+ state: string;
621
+ stateAbbrev: string;
622
+ populated: boolean;
623
+ provider: string;
624
+ countyName?: string;
625
+ countySlug?: string;
626
+ note?: string;
627
+ }
628
+ interface CityZoningIndex {
629
+ lastUpdated: string;
630
+ cities: CityZoningIndexEntry[];
631
+ }
632
+
633
+ /** Rows per upstream request, the same on every provider and every tool. */
634
+ declare const CITY_RECORD_LIMIT = 30;
635
+ interface SplitStreet {
636
+ /** Digits only. */
637
+ number: string;
638
+ /** The street name with a leading directional and a trailing suffix removed. */
639
+ name: string;
640
+ }
641
+ /**
642
+ * "1422 N Western Ave" -> { number: "1422", name: "Western" }. Null when the
643
+ * typed street carries no leading house number, which makes the caller fall
644
+ * back to the plain substring match. A unit glued to the number ("1422A",
645
+ * "1422-B") is dropped; the name keeps at least one token.
646
+ */
647
+ declare function splitStreet(street: string): SplitStreet | null;
648
+ /**
649
+ * The street NAME to match on a dataset whose table splits the address across
650
+ * columns (`addressParts`) but maps no `streetNumber` column. Such a name
651
+ * column holds "MARILLA" while "1500" and "ST" sit in their own columns, so the
652
+ * typed line as one substring finds almost nothing (Dallas violations, live
653
+ * probe 2026-10-13: '%Marilla St%' on str_nam matched 6 of 109 rows, 101 of
654
+ * which carry the type in str_suffix; '%Marilla%' matched all 109). The site
655
+ * page still sends the typed line (propertyQueryUrl, casesQueryUrl); the agent
656
+ * surfaces match the derived name.
657
+ *
658
+ * The roles come from the column ORDER the registry already carries: the
659
+ * display composers (PropertyReportTabs, zoning-providers) join addressParts in
660
+ * this order, number first. The name column is `fields.address`; a column
661
+ * before it is the house number, a second column before it is a directional,
662
+ * a column after it is the street type. Each is taken off the typed street at
663
+ * most once, only when its column exists: the leading house number (a glued
664
+ * unit or range stays with it: "1422A", "1252-1270"), then one leading
665
+ * directional (N S E W NE NW SE SW, or the full words), then one trailing
666
+ * street type (optional period). The name keeps at least one token, so a lone
667
+ * number or a lone type is sent as typed. Unchanged when the parts give no
668
+ * role: no parts, the name column not among them, or a mapped number column
669
+ * (then the split clause in propertyQueryUrl owns the number).
670
+ */
671
+ declare function splitAddressStreetName(parts: readonly string[] | undefined, nameColumn: string | undefined, numberColumn: string | undefined, street: string): string;
672
+ /**
673
+ * The exact upstream URL the Property Report sends for one dataset and one
674
+ * typed street ("" browses newest-first with no address filter). Behaviour
675
+ * preserving extraction of PropertyReportTabs.fetchDataset: the four provider
676
+ * branches below are its four branches, and PropertyReportTabs.test.tsx pins
677
+ * the URLs. The split-address clause only engages when the dataset maps a
678
+ * streetNumber column AND the street parses to number + name.
679
+ */
680
+ declare function propertyQueryUrl(ds: PropertyDataset, street: string): string;
681
+ /**
682
+ * The exact upstream URL the Zoning Cases tool sends for a docket and a typed
683
+ * street: the Socrata and ArcGIS address adapters in zoning-providers.ts, whose
684
+ * URLs zoning-providers.test.ts pins. For a location or parcel lookup only the
685
+ * empty street has a single-URL answer (the newest-first browse every adapter
686
+ * degrades to); a typed street needs a geocoded point or a parcel id first, so
687
+ * it returns null there (see casesLocationTemplate and the parcel query note).
688
+ */
689
+ declare function casesQueryUrl(src: CasesSource, street: string, statuses?: string[]): string | null;
690
+ /**
691
+ * Placeholder an agent replaces with "lon,lat" (WGS84) in a location template.
692
+ * The only placeholder: a street never appears in a template, because a typed
693
+ * street has to be escaped for the provider's SQL and a template invites pasting
694
+ * it in raw ("O'Brien" would close the literal). A street goes through
695
+ * propertyQueryUrl / casesQueryUrl (the package's buildCityQuery, the hosted
696
+ * tool's query_url), which escape it.
697
+ */
698
+ declare const POINT_PLACEHOLDER = "{LON},{LAT}";
699
+ /**
700
+ * Polygon-only dockets (Denver, Charlotte, Atlanta, Durham): the URL the
701
+ * location adapter sends once it has a point, with {LON},{LAT} where the point
702
+ * goes. The parameter order is the adapter's (zoning-providers.ts
703
+ * ArcgisLocationProvider), so this is the request the site makes, not a
704
+ * paraphrase of it.
705
+ */
706
+ declare function casesLocationTemplate(src: CasesSource, statuses?: string[]): string | null;
707
+ /**
708
+ * The current-zoning map lookup (Dallas): one point-intersect against the base
709
+ * zoning layer, with {LON},{LAT} where the point goes. Mirrors
710
+ * ZoningCasesTool.fetchCurrentZoning, outFields included.
711
+ */
712
+ declare function currentZoningTemplate(cz: CurrentZoningSource): string;
713
+ type CityKind = DatasetKind | "zoning";
714
+ interface CitySummary {
715
+ slug: string;
716
+ /** Display name: the property registry's where both registries list the city. */
717
+ city: string;
718
+ state: string;
719
+ stateAbbrev: string;
720
+ countyName?: string;
721
+ countySlug?: string;
722
+ kinds: CityKind[];
723
+ /** Every name either registry uses for the city, for matching. */
724
+ names: string[];
725
+ }
726
+ /**
727
+ * Merge the two registries' populated index entries into one summary per slug.
728
+ * Property kinds come from the index entry's `datasets` (the file's dataset
729
+ * keys, held in the index so a reader with only the index can state them);
730
+ * every zoning entry contributes "zoning". Names from both registries are kept
731
+ * for matching ("Washington, DC" and "Washington"; "New York City" and "New
732
+ * York"); the property registry's name is displayed when both exist.
733
+ */
734
+ declare function mergeCityIndexes(property: readonly CityPropertyIndexEntry[], zoning: readonly CityZoningIndexEntry[]): CitySummary[];
735
+ /**
736
+ * Resolve a city reference against a summary list: slug, then exact normalised
737
+ * name, then "Name, ST" with the state read off the end, then the alias list.
738
+ * Returns 0, 1 or many: two cities called Columbus in two states come back as a
739
+ * list unless `state` narrows them. No lat/lon and no centroid guess: the
740
+ * registry has no city boundaries, and neighbours like Phoenix, Mesa and
741
+ * Scottsdale share borders.
742
+ */
743
+ declare function findCityIn(cities: readonly CitySummary[], ref: string, state?: string): CitySummary[];
744
+ /** Every covered city inside one atlas county, by the atlas's state and county slugs. */
745
+ declare function citiesForCountyIn(cities: readonly CitySummary[], stateSlug: string, countySlug: string): CitySummary[];
746
+ /** Path of the city's page on urbankitstudio.com for one kind of data. */
747
+ declare function cityPath(slug: string, kind: CityKind): string;
748
+ type CityProvider = "socrata" | "arcgis" | "ckan" | "carto";
749
+ type CityLookup = "address" | "location" | "parcel";
750
+ /**
751
+ * A point lookup's request with its numeric placeholder. Only location lookups
752
+ * (polygon dockets, current-zoning maps) carry one: an address lookup has no
753
+ * template, since its street must be escaped (see POINT_PLACEHOLDER).
754
+ */
755
+ interface CityQueryTemplate {
756
+ /** The endpoint the parameters are appended to. */
757
+ base: string;
758
+ /** Query parameters as sent, with the placeholder un-encoded inside the value. */
759
+ params: Record<string, string>;
760
+ /** The token to replace: {LON},{LAT}, longitude first. */
761
+ substitute: string;
762
+ }
763
+ interface CityDatasetDescriptor {
764
+ /** The city this dataset belongs to, so a descriptor can be queried on its own. */
765
+ citySlug: string;
766
+ kind: CityKind;
767
+ /** Zoning only: an address-searchable case log, or the current zoning map. */
768
+ zoningMode?: "cases" | "current-zoning";
769
+ provider: CityProvider;
770
+ endpoint: string;
771
+ resourceId?: string;
772
+ lookup: CityLookup;
773
+ addressField?: string;
774
+ addressParts?: string[];
775
+ streetNumberField?: string;
776
+ /** The column the dataset sorts by, newest first. */
777
+ dateField?: string;
778
+ /** A filter that is part of the dataset's definition; keep it in every query. */
779
+ scopeWhere?: string;
780
+ /** Canonical name -> column name, as the registry maps it. */
781
+ fields: Record<string, string | string[]>;
782
+ statusBuckets?: PropertyStatusBuckets | ZoningStatusBuckets;
783
+ coverage?: string;
784
+ scopeNote?: string;
785
+ /**
786
+ * Always true: the site calls every registered dataset from the browser, so
787
+ * a source without CORS cannot be registered. An invariant, not a stored flag.
788
+ */
789
+ corsEnabled: true;
790
+ freshness: {
791
+ lastVerified: string;
792
+ latestRecordDate: string | null;
793
+ dateField: string | null;
794
+ };
795
+ /** Location lookups only; null for an address or parcel lookup. */
796
+ queryTemplate: CityQueryTemplate | null;
797
+ /** Newest-first with no street filter: returns rows whenever the dataset is live. */
798
+ sampleQuery: string | null;
799
+ queryNote: string;
800
+ }
801
+ /**
802
+ * Every dataset a city publishes, violations then permits then zoning. Either
803
+ * record may be null when the city is in one registry only.
804
+ */
805
+ declare function cityDatasetDescriptors(property: CityPropertyRecord | null | undefined, zoning: CityZoningRecord | null | undefined, kind?: CityKind): CityDatasetDescriptor[];
806
+ /**
807
+ * The street an agent query matches for this descriptor: the derived street
808
+ * name on a split-address dataset with no mapped number column (see
809
+ * splitAddressStreetName), otherwise the street as typed. Callers pass the
810
+ * result to datasetQueryUrl and report it as the street used.
811
+ */
812
+ declare function streetForDataset(d: CityDatasetDescriptor, street: string): string;
813
+ /** The hosted tool's cap on a street argument, applied here too (splitStreet backtracks on a long run of digits). */
814
+ declare const CITY_STREET_MAX_LEN = 120;
815
+ interface CityFilter {
816
+ /** A 2-letter code ("TX") or a state name ("Texas"). */
817
+ state?: string;
818
+ kind?: CityKind;
819
+ /** An atlas county slug ("maricopa-county"). */
820
+ countySlug?: string;
821
+ }
822
+ /** Every covered city, optionally narrowed by state, dataset kind or county. */
823
+ declare function listCities(filter?: CityFilter): CitySummary[];
824
+ /**
825
+ * Resolve a slug ("fort-worth"), a name ("Fort Worth"), a name with its state
826
+ * ("Fort Worth, TX") or an alias ("NYC", "DC"). 0, 1 or many: an ambiguous
827
+ * name comes back as a list, which `state` narrows.
828
+ */
829
+ declare function findCity(ref: string, state?: string): CitySummary[];
830
+ /** The city's code-violation and building-permit registry record. */
831
+ declare function getCityProperty(slug: string): CityPropertyRecord | undefined;
832
+ /** The city's zoning-case registry record. */
833
+ declare function getCityZoning(slug: string): CityZoningRecord | undefined;
834
+ /** Every dataset the city publishes (violations, permits, zoning), or one kind. */
835
+ declare function cityDatasets(slug: string, kind?: CityKind): CityDatasetDescriptor[];
836
+ /**
837
+ * The URL the hosted tool answers with for this dataset and street ("" for the
838
+ * newest-first browse): the site's own request, except that a dataset whose
839
+ * table splits the address across columns with no mapped number column is
840
+ * matched on the derived street name (streetForDataset; the site's URL as sent
841
+ * is propertyQueryUrl / casesQueryUrl). Null when the lookup needs a point or a
842
+ * parcel id first: use dataset.queryTemplate then. Throws a RangeError for a
843
+ * street over CITY_STREET_MAX_LEN characters and a TypeError for malformed text.
844
+ */
845
+ declare function buildCityQuery(dataset: CityDatasetDescriptor, street: string): string | null;
846
+ /** Every covered city inside one atlas county (Maricopa County lists each of its cities). */
847
+ declare function citiesForCounty(stateSlug: string, countySlug: string): CitySummary[];
848
+
849
+ declare const cityPropertyIndex: CityPropertyIndex;
850
+ declare const cityZoningIndex: CityZoningIndex;
851
+
852
+ export { type Atlas, type AtlasIndex, CITY_RECORD_LIMIT, CITY_STREET_MAX_LEN, type CapabilityBasis, type CapabilityBasisType, type CapabilityField, type CapabilityOverrides, type CapabilityStatus, type CaseFieldMap, type CasesSource, type CityDatasetDescriptor, type CityFilter, type CityKind, type CityLookup, type CityPropertyIndex, type CityPropertyIndexEntry, type CityPropertyRecord, type CityProvider, type CityQueryTemplate, type CitySource, type CitySummary, type CityZoningIndex, type CityZoningIndexEntry, type CityZoningRecord, type ContactInfo, type CountyAdvisory, type CountyRecord, type CurrentZoningFieldMap, type CurrentZoningSource, type DatasetKind, type DeepLinkCounty, type EndpointRecord, type EndpointStatus, type GeocoderConfig, type GeocoderProvider, LIVE_STATUS_URL, type LicenseType, POINT_PLACEHOLDER, type PropertyDataset, type PropertyDatasets, type PropertyFieldMap, type PropertySource, type PropertySourceType, type PropertyStatusBuckets, type SearchField, type ServiceType, type SplitStreet, type StateFile, type StateIndexEntry, type VerifiedBy, type ZoningByAddressSource, type ZoningSourceType, type ZoningStatusBuckets, type ZoningToolKind, atlas, atlasIndex, buildCityQuery, buildParcelLookupDeepLink, canonicalLayerUrl, casesLocationTemplate, casesQueryUrl, citiesForCounty, citiesForCountyIn, cityDatasetDescriptors, cityDatasets, cityPath, cityPropertyIndex, cityZoningIndex, countyOffersAttributeSearch, countyPath, countySlugFromName, currentZoningTemplate, findCity, findCityIn, findCounty, findCountyByFips, findState, getCityProperty, getCityZoning, isReviewedUnservable, listCities, listCountiesByState, listStates, mergeCityIndexes, offersAttributeSearch, offersPagination, propertyQueryUrl, reviewedCapability, slugify, splitAddressStreetName, splitStreet, statePath, streetForDataset };