@yext/pages-components 1.0.4 → 1.0.6

package/dist/index.d.ts

@@ -618,348 +618,566 @@ type LinkProps = CTALinkProps | HREFLinkProps;
  */
 declare const Link: React$1.ForwardRefExoticComponent<(Omit<HREFLinkProps, "ref"> | Omit<CTAWithChildrenLinkProps, "ref"> | Omit<CTAWithoutChildrenLinkProps, "ref">) & React$1.RefAttributes<HTMLAnchorElement>>;
 
+declare enum Unit {
+    DEGREE = "deg",
+    KILOMETER = "km",
+    MILE = "mi",
+    RADIAN = "r"
+}
+declare enum Projection {
+    MERCATOR = "mercator",
+    SPHERICAL = "spherical"
+}
+
 /**
  * This class represents a point on a sphere defined by latitude and longitude.
  * Latitude is a degree number in the range [-90, 90].
  * Longitude is a degree number without limits but is normalized to [-180, 180).
  */
 declare class Coordinate$1 {
+    _lat: number;
+    _lon: number;
     /**
      * Constructor takes either 1 or 2 arguments.
      * 2 arguments: latitude and longitude.
-     * 1 argument: an object with at least one {@link module:@yext/components-geo~Coordinate~LATITUDE_ALIASES latitude alias}
-     * and one one {@link module:@yext/components-geo~CoordinateCoordinate~LONGITUDE_ALIASES longitude alias}.
-     * @param {number|Object} latitudeOrObject
-     * @param {number} [longitude] Optional only if the first argument is a {@link module:@yext/components-geo~Coordinate Coordinate}-like object
+     * 1 argument: an object with at least one {@link LATITUDE_ALIASES | latitude alias}
+     * and one one {@link LONGITUDE_ALIASES | longitude alias}.
+     * @param longitude - Optional only if the first argument is a {@link Coordinate}-like object
      */
-    constructor(latitudeOrObject: number | Object, longitude?: number | undefined);
-    set latitude(newLat: number);
+    constructor(latitudeOrObject: number | object, long?: number);
     /**
      * Degrees latitude in the range [-90, 90].
      * If setting a value outside this range, it will be set to -90 or 90, whichever is closer.
-     * @type {number}
      */
     get latitude(): number;
-    set longitude(newLon: number);
+    set latitude(newLat: number);
     /**
      * Degrees longitude in the range [-Infinity, Infinity].
-     * @type {number}
      */
     get longitude(): number;
+    set longitude(newLon: number);
     /**
      * Degrees longitude in the range [-180, 180).
      * If the coordinate's longitude is outside this range, the equivalent value within it is used.
-     * Examples: 123 => 123, 270 => -90, -541 => 179
-     * @type {number}
+     * Examples: 123 =\> 123, 270 =\> -90, -541 =\> 179
      */
     get normalLon(): number;
-    _lat: number | undefined;
-    _lon: number | undefined;
     /**
      * Add distance to the coordinate to change its position.
-     * @param {number} latDist latitude distance
-     * @param {number} lonDist longitude distance
-     * @param {module:@yext/components-geo~Unit} [unit=Unit.DEGREE] The unit of latDist and lonDist
-     * @param {module:@yext/components-geo~Projection} [projection=Projection.SPHERICAL] The projection of Earth (not relevant when using a physical distance unit, e.g. Mile)
+     * @param latDist - latitude distance
+     * @param lonDist - longitude distance
+     * @param unit - The unit of latDist and lonDist
+     * @param projection - The projection of Earth (not relevant when using a physical distance unit, e.g. Mile)
      */
-    add(latDist: number, lonDist: number, unit?: any, projection?: any): void;
+    add(latDist: number, lonDist: number, unit?: Unit, projection?: Projection): void;
     /**
      * Calculate the distance from this coordinate to another coordinate.
-     * @param {module:@yext/components-geo~Coordinate} coordinate
-     * @param {module:@yext/components-geo~Unit} [unit=Unit.MILE] The unit of distance
-     * @param {module:@yext/components-geo~Projection} [projection=Projection.SPHERICAL] The projection of Earth (not relevant when using a physical distance unit, e.g. Mile)
-     * @returns {number} Distance in the requested unit
+     * @param unit - The unit of distance
+     * @param projection - The projection of Earth (not relevant when using a physical distance unit, e.g. Mile)
+     * @returns Distance in the requested unit
      */
-    distanceTo(coordinate: any, unit?: any, projection?: any): number;
+    distanceTo(coordinate: Coordinate$1, unit?: Unit, projection?: Projection): number;
     /**
      * Test if this coordinate has the same latitude and longitude as another.
-     * @param {module:@yext/components-geo~Coordinate} coordinate
-     * @returns {boolean}
      */
-    equals(coordinate: any): boolean;
+    equals(coordinate: Coordinate$1): boolean;
     /**
      * Get the coordinate as a string that can be used in a search query.
-     * Example: {latitude: -45, longitude: 123} => '-45,123'
-     * @returns {string}
+     * Example: \{latitude: -45, longitude: 123\} =\> '-45,123'
      */
     searchQueryString(): string;
 }
 
 /**
  * This class represents a bounded coordinate region of a sphere.
- * The bounds are defined by two {@link module:@yext/components-geo~Coordinate Coordinates}: southwest and northeast.
+ * The bounds are defined by two {@link Coordinates}: southwest and northeast.
  * If the northeast coordinate does not have a greater latitude and longitude than the soutwest
  * coordinate, the behavior of this object is undefined.
  */
 declare class GeoBounds {
+    _ne: Coordinate$1;
+    _sw: Coordinate$1;
     /**
-     * Create a new {@link module:@yext/components-geo~GeoBounds GeoBounds} with minimal area that
+     * Create a new {@link GeoBounds} with minimal area that
      * contains all the given coordinates
-     * @param {module:@yext/components-geo~Coordinate[]} coordinates
-     * @returns {module:@yext/components-geo~GeoBounds}
      */
-    static fit(coordinates: any): any;
+    static fit(coordinates: Coordinate$1[]): GeoBounds;
     /**
-     * @param {module:@yext/components-geo~Coordinate} sw Southwest coordinate
-     * @param {module:@yext/components-geo~Coordinate} ne Northeast coordinate
+     * @param sw - Southwest coordinate
+     * @param ne - Northeast coordinate
      */
-    constructor(sw: any, ne: any);
-    _ne: Coordinate$1;
-    _sw: Coordinate$1;
-    set ne(newNE: any);
+    constructor(sw: Coordinate$1, ne: Coordinate$1);
     /**
      * Northeast coordinate
-     * @type {module:@yext/components-geo~Coordinate}
      */
-    get ne(): any;
-    set sw(newSW: any);
+    get ne(): Coordinate$1;
+    set ne(newNE: Coordinate$1);
     /**
      * Southwest coordinate
-     * @type {module:@yext/components-geo~Coordinate}
      */
-    get sw(): any;
+    get sw(): Coordinate$1;
+    set sw(newSW: Coordinate$1);
     /**
      * Whether the coordinate lies within the region defined by the bounds.
-     * {@link module:@yext/components-geo~Coordinate#normalLon Normalized longitudes} are used for the
+     * {@link Normalized | longitudes} are used for the
      * bounds and the coordinate.
-     * @param {module:@yext/components-geo~Coordinate} coordinate
-     * @returns {boolean}
      */
-    contains(coordinate: any): boolean;
+    contains(coordinate: Coordinate$1): boolean;
     /**
      * Extend the bounds if necessary so that the coordinate is contained by them.
-     * @param {module:@yext/components-geo~Coordinate} coordinate
      */
-    extend(coordinate: any): void;
+    extend(coordinate: Coordinate$1): void;
     /**
      * Calculate the center of the bounds using the given projection.
      * To find the visual center on a Mercator map, use Projection.MERCATOR.
      * To find the center for geolocation or geosearch purposes, use Projection.SPHERICAL.
-     * @param {module:@yext/components-geo~Projection} [projection=Projection.SPHERICAL]
-     * @returns {module:@yext/components-geo~Coordinate}
      */
-    getCenter(projection?: any): any;
+    getCenter(projection?: Projection): Coordinate$1;
 }
 
 /**
- * An interactive map that supports various map providers, such as Google Maps and Mapbox, with a
- * single API. Code written using this class functions approximately the same regardless of the map
- * provider used. Any map provider can be supported via an instance of {@link module:@yext/components-maps~MapProvider MapProvider}.
+ * {@link ProviderMap} options class
  */
-declare class Map$1 {
+declare class ProviderMapOptions {
     /**
-     * The {@link module:@yext/components-maps~MapProvider MapProvider} for the map must be loaded
-     * before calling this constructor.
-     * @param {module:@yext/components-maps~MapOptions} options
-     */
-    constructor(options: any);
-    _defaultCenter: any;
-    _defaultZoom: any;
-    _legendPins: any;
-    _provider: any;
-    _singlePinZoom: any;
-    _wrapper: any;
-    _padding: {};
-    _cachedBounds: GeoBounds | null;
-    _resolveIdle: () => null;
-    _resolveMoving: () => null;
-    _idlePromise: Promise<void>;
-    _panHandlerRunning: boolean;
-    _panStartHandlerRunning: boolean;
-    _map: any;
-    _currentBounds: any;
+     * @param wrapper - The wrapper element that the map will be inserted into
+     */
+    providerMapClass: typeof ProviderMap;
+    wrapper: HTMLElement | null;
+    controlEnabled: boolean;
+    panHandler: PanHandler;
+    panStartHandler: PanStartHandler;
+    providerOptions: {
+        [key: string]: any;
+    };
+    constructor(provider: MapProvider, wrapper: HTMLElement | null);
     /**
-     * Set the map bounds so that all the given coordinates are within the {@link module:@yext/components-maps~MapOptions#withPadding padded}
-     * view.
-     * @param {module:@yext/components-tsx-geo~Coordinate[]} coordinates
-     * @param {boolean} [animated=false] Whether to transition smoothly to the new bounds
-     * @param {number} [maxZoom=singlePinZoom] The max zoom level after fitting. Uses {@link module:@yext/components-maps~MapOptions#withSinglePinZoom singlePinZoom}
-     *   by default.
+     * @param controlEnabled - Whether the user can interact with the map
      */
-    fitCoordinates(coordinates: any, animated?: boolean | undefined, maxZoom?: number | undefined): void;
+    withControlEnabled(controlEnabled: boolean): ProviderMapOptions;
     /**
-     * Get the current visible region of the map. If the map is zoomed out to show multiple copies of
-     * the world, the longitude bounds will be outside [-180, 180) but the center will always be
-     * within [-180, 180).
-     * @returns {module:@yext/components-tsx-geo~GeoBounds}
+     * @param panHandler - Function called after the map bounds change
      */
-    getBounds(): any;
+    withPanHandler(panHandler: PanHandler): ProviderMapOptions;
     /**
-     * @returns {module:@yext/components-tsx-geo~Coordinate} The center of the current visible region of
-     *   the map
+     * @param panStartHandler - Function called before the map bounds change
      */
-    getCenter(): any;
+    withPanStartHandler(panStartHandler: PanStartHandler): ProviderMapOptions;
     /**
-     * Intended for internal use only
-     * @returns {module:@yext/components-maps~ProviderMap} The map's {@link module:@yext/components-maps~ProviderMap ProviderMap}
-     *   instance
+     * @param providerOptions - A free-form object used to set any additional provider-specific
+     *   options, usually by passing the object to the map's constructor
      */
-    getProviderMap(): any;
+    withProviderOptions(providerOptions: object): ProviderMapOptions;
     /**
-     * To standardize zoom for all providers, zoom level is calculated with this formula:
-     * zoom = log2(pixel width of equator) - 8.
-     * At zoom = 0, the entire world is 256 pixels wide.
-     * At zoom = 1, the entire world is 512 pixels wide.
-     * Zoom 2 → 1024 pixels, zoom 3 → 2056 pixels, etc.
-     * Negative and non-integer zoom levels are valid and follow the formula.
-     * @returns {number} The current zoom level of the map
+     * @returns An instance of a subclass of {@link ProviderMap}
+     *   for the given {@link MapProvider}
+     */
+    build(): ProviderMap;
+}
+/**
+ * This class is an interface that should be implemented for each map provider, such as Google Maps.
+ * It is used as an API for a {@link Map} to control a
+ * provider-specific map instance. Ideally, this class should have minimal functionality so that
+ * adding a new provider is easy and behavior is as consistent as possible across all providers.
+ */
+declare class ProviderMap {
+    /**
+     * The constructor creates a map instance using the provider's API and initializes it with all the
+     * given options. See {@link ProviderMapOptions}
+     * for the supported options.
+     */
+    _panHandler: PanHandler;
+    _panStartHandler: PanStartHandler;
+    constructor(options: ProviderMapOptions);
+    /**
+     * The current center of the map
+     */
+    getCenter(): Coordinate$1;
+    /**
+     * Zoom level complies with the specifications in {@link Map#getZoom}
+     * @returns The current zoom level of the map
      */
     getZoom(): number;
     /**
-     * Returns when the map is not moving.
-     * Use map.idle().then(callback) to run callback immediately if the map is currently idle or once
-     * the map becomes idle if it's not.
+     * @param coordinate - The new center for the map
+     * @param animated - Whether to transition smoothly to the new center
      */
-    idle(): Promise<void>;
+    setCenter(_: Coordinate$1, __: boolean): void;
     /**
-     * Returns when the map is moving.
-     * Use map.moving().then(callback) to run callback immediately if the map is currently moving or
-     * once the map starts moving if it's not.
+     * Zoom level complies with the specifications in {@link Map#getZoom}
+     * @param zoom - The new zoom level for the map
+     * @param animated - Whether to transition smoothly to the new zoom
      */
-    moving(): Promise<void>;
+    setZoom(_: number, __: boolean): void;
     /**
-     * @returns {module:@yext/components-maps~MapPinOptions} A {@link module:@yext/components-maps~MapPinOptions MapPinOptions}
-     *   instance with the same provider as this map
+     * @param center - Must be convertible to {@link Coordinate}
+     * @param animated - Whether to transition smoothly to the new bounds
+     * @see ProviderMap#setZoom
+     * @see ProviderMap#setCenter
+     */
+    setZoomCenter(zoom: number, center: Coordinate$1, animated: boolean): void;
+}
+
+/**
+ * {@link ProviderPin} options class
+ */
+declare class ProviderPinOptions {
+    providerPinClass: typeof ProviderPin;
+    clickHandler: PinClickHandler;
+    focusHandler: PinFocusHandler;
+    hoverHandler: PinHoverHandler;
+    icons: {
+        [key: string]: string;
+    };
+    hasPinUrl: boolean;
+    constructor(provider: MapProvider);
+    /**
+     * @param clickHandler - Function called when the pin is clicked
      */
-    newPinOptions(): any;
+    withClickHandler(clickHandler: PinClickHandler): ProviderPinOptions;
     /**
-     * Called when the map has finished moving, at most once per animation frame.
-     * Passes the current and previous bounds to the custom pan handler given by {@link module:@yext/components-maps~MapOptions#withPanHandler MapOptions#withPanHandler}
+     * @param focusHandler - Function called when the pin becomes (un)focused
      */
-    panHandler(): void;
+    withFocusHandler(focusHandler: PinFocusHandler): ProviderPinOptions;
     /**
-     * Called when the map has started moving, at most once per animation frame.
-     * Passes the current bounds to the custom pan handler given by {@link module:@yext/components-maps~MapOptions#withPanStartHandler MapOptions#withPanStartHandler}
+     * @param hoverHandler - Function called when the pin becomes (un)hovered
      */
-    panStartHandler(): void;
+    withHoverHandler(hoverHandler: PinHoverHandler): ProviderPinOptions;
     /**
-     * @param {Object} bounds
-     * @param {Object} bounds.ne The northeast corner of the bounds -- must be convertible to {@link module:@yext/components-tsx-geo~Coordinate Coordinate}
-     * @param {Object} bounds.sw The southwest corner of the bounds -- must be convertible to {@link module:@yext/components-tsx-geo~Coordinate Coordinate}
-     * @param {boolean} [animated=false] Whether to transition smoothly to the new bounds
-     * @param {Object} [padding={}]
-     * @param {number|module:@yext/components-maps~PaddingFunction} padding.bottom Minimum number of
-     *   pixels between the map's bottom edge and a pin
-     * @param {number|module:@yext/components-maps~PaddingFunction} padding.left Minimum number of
-     *   pixels between the map's left edge and a pin
-     * @param {number|module:@yext/components-maps~PaddingFunction} padding.right Minimum number of
-     *   pixels between the map's right edge and a pin
-     * @param {number|module:@yext/components-maps~PaddingFunction} padding.top Minimum number of
-     *   pixels between the map's top edge and a pin
-     * @param {number} [maxZoom=Infinity]
-     */
-    setBounds({ ne, sw }: {
-        ne: Object;
-        sw: Object;
-    }, animated?: boolean | undefined, padding?: Object | undefined, maxZoom?: number | undefined): void;
-    /**
-     * @param {Object} coordinate Must be convertible to {@link module:@yext/components-tsx-geo~Coordinate Coordinate}
-     * @param {boolean} [animated=false] Whether to transition smoothly to the new center
-     */
-    setCenter(coordinate: Object, animated?: boolean | undefined): void;
-    /**
-     * Padding is used by {@link module:@yext/components-maps~Map#fitCoordinates Map#fitCoordinates}.
-     * Padding can either be constant values or funtions that return a padding value.
-     * Constant values are good if the map should always have the same padding on every breakpoint.
-     * Functions are useful if the map should have different padding at different breakpoints/layouts.
-     * The function can check window.innerWidth or any other condition before returning a number.
-     * @param {Object} padding
-     * @param {number|module:@yext/components-maps~PaddingFunction} padding.bottom Minimum number of
-     *   pixels between the map's bottom edge and a pin
-     * @param {number|module:@yext/components-maps~PaddingFunction} padding.left Minimum number of
-     *   pixels between the map's left edge and a pin
-     * @param {number|module:@yext/components-maps~PaddingFunction} padding.right Minimum number of
-     *   pixels between the map's right edge and a pin
-     * @param {number|module:@yext/components-maps~PaddingFunction} padding.top Minimum number of
-     *   pixels between the map's top edge and a pin
-     * @returns {module:@yext/components-maps~Map}
+     * Similar to {@link MapPinOptions#withIcon},
+     * but all icons are given as a map of key =\> icon. If a provider pin instance needs an icon to be
+     * a specialized class rather than a simple URL, the icons in this object can be converted in this
+     * function and assigned back to the icons object instead of being recreated from the URL every
+     * time the pin's icon changes.
+     * @param icons - Map of a string key to the URL or data URI of an image
      */
-    setPadding({ bottom, left, right, top, }: Object): any;
+    withIcons(icons: {
+        [key: string]: string;
+    }): ProviderPinOptions;
     /**
-     * @param {module:@yext/components-maps~Map~panHandler} panHandler
+     * @param hasPinUrl - Pass through from MapPin class
+     * @returns
      */
-    setPanHandler(panHandler: any): void;
-    _panHandler: any;
+    withHasPinUrl(hasPinUrl: boolean): this;
     /**
-     * @param {module:@yext/components-maps~Map~panStartHandler} panStartHandler
+     * @returns An instance of a subclass of {@link ProviderPin}
+     *   for the given {@link MapProvider}
      */
-    setPanStartHandler(panStartHandler: any): void;
-    _panStartHandler: any;
+    build(): ProviderPin;
+}
+/**
+ * This class is an interface that should be implemented for each map provider, such as Google Maps.
+ * It is used as an API for a {@link MapPin} to control a
+ * provider-specific pin instance. Ideally, this class should have minimal functionality so that
+ * adding a new provider is easy and behavior is as consistent as possible across all providers.
+ */
+declare class ProviderPin {
+    _clickHandler: PinClickHandler;
+    _focusHandler: PinFocusHandler;
+    _hoverHandler: PinHoverHandler;
+    _icons: {
+        [key: string]: string;
+    };
     /**
-     * @param {number} zoom
-     * @param {boolean} [animated=false] Whether to transition smoothly to the new zoom
-     * @see module:@yext/components-maps~Map#getZoom
+     * The constructor creates a pin instance using the provider's API and initializes it with all the
+     * given options. See {@link ProviderPinOptions}
+     * for the supported options.
      */
-    setZoom(zoom: number, animated?: boolean | undefined): void;
+    constructor(options: ProviderPinOptions);
     /**
-     * @param {number} zoom
-     * @param {Object} center Must be convertible to {@link module:@yext/components-tsx-geo~Coordinate Coordinate}
-     * @param {boolean} [animated=false] Whether to transition smoothly to the new bounds
-     * @see module:@yext/components-maps~Map#setZoom
-     * @see module:@yext/components-maps~Map#setCenter
+     * @param coordinate - The position of the pin
      */
-    setZoomCenter(zoom: number, center: Object, animated?: boolean | undefined): void;
+    setCoordinate(_: Coordinate$1): void;
     /**
-     * Set the map state to idle
-     * @protected
+     * Remove the pin from its current map and, if newMap is not null, add it to the new map.
+     * @param newMap - The new map -- if null, the pin will not be
+     *   shown on any map
+     * @param currentMap - The current map -- if null, the pin is
+     *   not shown on any map
      */
-    protected _setIdle(): void;
-    _movingPromise: Promise<any> | undefined;
+    setMap(_: Map$1 | null, __: Map$1 | null): void;
     /**
-     * Set the map state to moving
-     * @protected
+     * Apply the given properties to modify the appearance of the pin.
+     * @see PinProperties
+     */
+    setProperties(_: PinProperties): void;
+}
+
+type ProviderLoadFunction = (resolve: () => void, reject: () => void, apiKey: string, options: object) => void;
+/**
+ * {@link MapProvider} options class
+ */
+declare class MapProviderOptions {
+    loadFunction: ProviderLoadFunction;
+    mapClass: typeof ProviderMap;
+    pinClass: typeof ProviderPin;
+    providerName: string;
+    constructor();
+    withLoadFunction(loadFunction: ProviderLoadFunction): MapProviderOptions;
+    /**
+     * @param mapClass - Subclass of {@link ProviderMap}
+     *   for the provider
+     */
+    withMapClass(mapClass: typeof ProviderMap): MapProviderOptions;
+    /**
+     * @param pinClass - Subclass of {@link ProviderPin} for the provider
+     */
+    withPinClass(pinClass: typeof ProviderPin): MapProviderOptions;
+    /**
+     * @param providerName - Name of the map provider
+     */
+    withProviderName(providerName: string): MapProviderOptions;
+    build(): MapProvider;
+}
+/**
+ * This class is used for loading the API for a map provider such as Google Maps and creating {@link ProviderMap}
+ * and {@link ProviderPin} instances.
+ * Provider map implementations return an instance of this class for their provider that you can use
+ * to load the API and pass in to {@link MapOptions} and {@link MapPinOptions} objects as the provider.
+ * Example using {@link GoogleMaps}, an instance of this
+ * class: GoogleMaps.load().then(() =\> map = new MapOptions().withProvider(GoogleMaps).build());
+ */
+declare class MapProvider {
+    _loadFunction: ProviderLoadFunction;
+    _mapClass: typeof ProviderMap;
+    _pinClass: typeof ProviderPin;
+    _providerName: string;
+    _loadPromise: Promise<void>;
+    _resolveLoad?: () => void;
+    _rejectLoad?: () => void;
+    _apiKey: string;
+    _loadInvoked: boolean;
+    _loaded: boolean;
+    _options: any;
+    constructor(options: MapProviderOptions);
+    /**
+     * Returns true if the map provider has been successfully loaded
+     */
+    get loaded(): boolean;
+    /**
+     * @see ~MapProviderOptions#withMapClass
+     */
+    getMapClass(): typeof ProviderMap;
+    /**
+     * @see MapProviderOptions#withPinClass
+     */
+    getPinClass(): typeof ProviderPin;
+    /**
+     * @see MapProviderOptions#withProviderName
+     */
+    getProviderName(): string;
+    /**
+     * Call {@link loadFunction}
+     * and resolve or reject when loading succeeds or fails
+     * @param apiKey - Provider API key -- uses value from {@link MapProvider#setLoadOptions}
+     *   if not passed
+     * @param options - Additional provider-specific options -- uses value from {@link MapProvider#setLoadOptions}
+     *   if not passed
+     */
+    load(apiKey?: string, options?: any): Promise<void>;
+    /**
+     * Resolves or rejects when the map provider has loaded successfully or unsuccessfully
+     */
+    ready(): Promise<void>;
+    /**
+     * Set the API key and provider options used on load. Does nothing if load was already called.
+     * @param apiKey - Provider API key
+     * @param options - Additional provider-specific options
+     */
+    setLoadOptions(apiKey: string, options?: object | null): void;
+}
+
+/**
+ * This class is used to set the appearance of a {@link MapPin}.
+ * Most properties are supported by all providers, but some are only supported by providers that
+ * implement {@link HTMLProviderPin}.
+ */
+declare class PinProperties {
+    _anchorX: number;
+    _anchorY: number;
+    _height: number;
+    _icon: string;
+    _srText: string;
+    _width: number;
+    _zIndex: number;
+    _class: string;
+    _element: HTMLElement | null;
+    constructor();
+    /**
+     * @returns The point in the pin that should be positioned over the coordinate, from 0
+     *   (left edge) to 1 (right edge)
+     */
+    getAnchorX(): number;
+    /**
+     * @returns The point in the pin that should be positioned over the coordinate, from 0
+     *   (top edge) to 1 (bottom edge)
+     */
+    getAnchorY(): number;
+    /**
+     * {@link HTMLProviderPins} only
+     * @returns The class of the wrapper element for an HTML pin
+     */
+    getClass(): string;
+    /**
+     * {@link HTMLProviderPins} only
+     * @returns The HTML pin element
+     */
+    getElement(): HTMLElement | null;
+    /**
+     * @returns The pixel height of the pin
+     */
+    getHeight(): number;
+    /**
+     * This returns a string key that can be used with {@link MapPin#getIcon}
+     * to get the icon image for a pin.
+     * @returns The unique name of the icon
+     */
+    getIcon(): string;
+    /**
+     * @returns The text that a screen reader reads when focused on the pin
+     */
+    getSRText(): string;
+    /**
+     * @returns The pixel width of the pin
+     */
+    getWidth(): number;
+    /**
+     * @returns The z-index of the pin
+     */
+    getZIndex(): number;
+    /**
+     * @see PinProperties#getAnchorX
+     */
+    setAnchorX(anchorX: number): PinProperties;
+    /**
+     * @see PinProperties#getAnchorY
+     */
+    setAnchorY(anchorY: number): PinProperties;
+    /**
+     * @see PinProperties#getClass
+     */
+    setClass(className: string): PinProperties;
+    /**
+     * @see PinProperties#getElement
+     */
+    setElement(element: HTMLElement): PinProperties;
+    /**
+     * @see PinProperties#getHeight
+     */
+    setHeight(height: number): PinProperties;
+    /**
+     * @see PinProperties#getIcon
+     */
+    setIcon(icon: string): PinProperties;
+    /**
+     * @see PinProperties#getSRText
+     */
+    setSRText(srText: string): PinProperties;
+    /**
+     * @see PinProperties#getWidth
+     */
+    setWidth(width: number): PinProperties;
+    /**
+     * @see PinProperties#getZIndex
      */
-    protected _setMoving(): void;
+    setZIndex(zIndex: number): PinProperties;
 }
 
+type PropertiesForStatus = (status: object) => PinProperties;
+type PinClickHandler = () => void;
+type PinFocusHandler = (focused: boolean) => void;
+type PinHoverHandler = (hovered: boolean) => void;
+/**
+ * {@link MapPin} options class
+ */
+declare class MapPinOptions {
+    /**
+     * Initialize with default options
+     */
+    coordinate: Coordinate$1;
+    hideOffscreen: boolean;
+    icons: {
+        [key: string]: string;
+    };
+    propertiesForStatus: PropertiesForStatus;
+    provider: MapProvider | null;
+    type: string;
+    hasPinUrl: boolean;
+    constructor();
+    /**
+     * @param coordinate - Must be convertible to {@link Coordinate}
+     */
+    withCoordinate(coordinate: Coordinate$1): MapPinOptions;
+    /**
+     * @param hideOffscreen - If true, the pin will only be rendered if it's in the visible
+     *   portion of the map to improve performance
+     */
+    withHideOffscreen(hideOffscreen: boolean): MapPinOptions;
+    /**
+     * @param key - The unique name for the icon, used in {@link PinProperties#getIcon}
+     *   and {@link PinProperties#setIcon}
+     * @param icon - The URL or data URI of the icon image
+     */
+    withIcon(key: string, icon: string): MapPinOptions;
+    withPropertiesForStatus(propertiesForStatus: PropertiesForStatus): MapPinOptions;
+    withProvider(provider: MapProvider | null): MapPinOptions;
+    /**
+     * @param hasPinUrl - If true, the pin's HTML element will be a div instead of a button since there is a nested anchor tag within the pin. This will fix current accessibility issues.
+     */
+    withHasPinUrl(hasPinUrl: boolean): MapPinOptions;
+    /**
+     * @param type - A string describing the type of the pin
+     */
+    withType(type: string): MapPinOptions;
+    build(): MapPin;
+}
 /**
- * A pin for a {@link module:@yext/components-maps~Map Map} that displays at a given {@link module:@yext/components-tsx-geo~Coordinate Coordinate}.
+ * A pin for a {@link Map} that displays at a given {@link Coordinate}.
  * A MapPin can be displayed on at most one Map at a time. Pins support event handlers for clicking,
  * hovering, and focusing. The pin can change its appearance based on its current status, which is
- * changed by {@link module:@yext/components-maps~MapPin#setStatus setStatus}.
+ * changed by {@link setStatus}.
  */
 declare class MapPin {
-    /**
-     * @param {module:@yext/components-maps~MapPinOptions} options
-     */
-    constructor(options: any);
-    _coordinate: any;
-    _hideOffscreen: any;
-    _icons: any;
-    _propertiesForStatus: any;
-    _type: any;
-    _clickHandler: () => null;
-    _focusHandler: (focused: any) => null;
-    _hoverHandler: (hovered: any) => null;
+    _coordinate: Coordinate$1;
+    _hideOffscreen: boolean;
+    _icons: {
+        [key: string]: string;
+    };
+    _propertiesForStatus: PropertiesForStatus;
+    _type: string;
+    _clickHandler: PinClickHandler;
+    _focusHandler: PinFocusHandler;
+    _hoverHandler: PinHoverHandler;
     _hidden: boolean;
-    _cancelHiddenUpdater: () => null;
-    _map: any;
-    _pin: any;
-    _status: {};
+    _cancelHiddenUpdater: () => void;
+    _map: Map$1 | null;
+    _pin: ProviderPin;
+    _status: object;
+    constructor(options: MapPinOptions);
     /**
-     * @returns {module:@yext/components-tsx-geo~Coordinate} The coordinate of the pin
+     * @returns The coordinate of the pin
      */
-    getCoordinate(): any;
+    getCoordinate(): Coordinate$1;
     /**
      * Get the icon for a string key, such as 'default', 'hovered', or 'selected'
-     * @param {string} key The unique name of the icon
-     * @returns {string} The URL or data URI of the icon image
-     * @see module:@yext/components-maps~MapPinOptions#withIcon
+     * @param key - The unique name of the icon
+     * @returns The URL or data URI of the icon image
+     * @see MapPinOptions#withIcon
      */
     getIcon(key: string): string;
     /**
-     * @returns {module:@yext/components-maps~Map} The map that the pin is currently on, or null if
+     * @returns The map that the pin is currently on, or null if
      * not on a map
      */
-    getMap(): any;
+    getMap(): Map$1 | null;
     /**
      * Intended for internal use only
-     * @returns {module:@yext/components-maps~ProviderPin} The pin's {@link module:@yext/components-maps~ProviderPin ProviderPin}
+     * @returns The pin's {@link ProviderPin}
      *   instance
      */
-    getProviderPin(): any;
+    getProviderPin(): ProviderPin;
     /**
-     * @returns {string} The string describing the type of pin
+     * @returns The string describing the type of pin
      */
     getType(): string;
     /**
@@ -968,107 +1186,269 @@ declare class MapPin {
     remove(): void;
     /**
      * Set a handler function for when the pin is clicked, replacing any previously set click handler.
-     * @param {module:@yext/components-maps~PinClickHandler} clickHandler
      */
-    setClickHandler(clickHandler: any): void;
+    setClickHandler(clickHandler: PinClickHandler): void;
     /**
-     * @param {Object} coordinate Must be convertible to {@link module:@yext/components-tsx-geo~Coordinate Coordinate}
+     * @param coordinate - Must be convertible to {@link Coordinate}
      */
-    setCoordinate(coordinate: Object): void;
+    setCoordinate(coordinate: Coordinate$1): void;
     /**
      * Set a handler function for when the pin is (un)focused, replacing any previously set focus handler.
-     * @param {module:@yext/components-maps~PinFocusHandler} focusHandler
      */
-    setFocusHandler(focusHandler: any): void;
+    setFocusHandler(focusHandler: PinFocusHandler): void;
     /**
      * Set a handler function for when the pin is (un)hovered, replacing any previously set hover handler.
-     * @param {module:@yext/components-maps~PinHoverHandler} hoverHandler
      */
-    setHoverHandler(hoverHandler: any): void;
+    setHoverHandler(hoverHandler: PinHoverHandler): void;
     /**
      * Add the pin to a map, removing it from its current map if on one.
-     * @param {?Map} map
      */
     setMap(map: Map$1 | null): void;
     /**
      * Assign all properties in an object to the pin's status.
-     * Example: if the pin's status is { a: true, b: true }, passing in { a: false, c: true } will
-     * change the pin's status to { a: false, b: true, c: true }
-     * @param {Object} status
+     * Example: if the pin's status is \{ a: true, b: true \}, passing in \{ a: false, c: true \} will
+     * change the pin's status to \{ a: false, b: true, c: true \}
      */
-    setStatus(status: Object): void;
+    setStatus(status: object): void;
     /**
      * Add or remove the pin from the map based on whether its coordinate is within the current bounds
-     * @protected
      */
-    protected _hideIfOffscreen(): void;
+    _hideIfOffscreen(): void;
 }
 
+type PaddingFunction = () => number;
+type PanHandler = (previousBounds?: GeoBounds, currentBounds?: GeoBounds) => void;
+type PanStartHandler = (currentBounds?: GeoBounds) => void;
+type PaddingObject = {
+    bottom?: number | PaddingFunction;
+    left?: number | PaddingFunction;
+    right?: number | PaddingFunction;
+    top?: number | PaddingFunction;
+};
 /**
- * This class is used for loading the API for a map provider such as Google Maps and creating {@link module:@yext/components-maps~ProviderMap ProviderMap}
- * and {@link module:@yext/components-maps~ProviderPin ProviderPin} instances.
- * Provider map implementations return an instance of this class for their provider that you can use
- * to load the API and pass in to {@link module:@yext/components-maps~MapOptions MapOptions} and {@link module:@yext/components-maps~MapPinOptions MapPinOptions} objects as the provider.
- * Example using {@link module:@yext/components-maps~GoogleMaps GoogleMaps}, an instance of this
- * class: GoogleMaps.load().then(() => map = new MapOptions().withProvider(GoogleMaps).build());
+ * {@link Map} options class
  */
-declare class MapProvider {
+declare class MapOptions {
+    controlEnabled: boolean;
+    defaultCenter: Coordinate$1;
+    defaultZoom: number;
+    legendPins: MapPin[];
+    padding: PaddingObject;
+    panHandler: PanHandler;
+    panStartHandler: PanStartHandler;
+    provider: MapProvider | null;
+    providerOptions: ProviderMapOptions | object;
+    singlePinZoom: number;
+    wrapper: HTMLElement | null;
     /**
-     * @param {module:@yext/components-maps~MapProviderOptions} options
+     * Initialize with default options
      */
-    constructor(options: any);
-    _loadFunction: any;
-    _mapClass: any;
-    _pinClass: any;
-    _providerName: any;
-    _loadPromise: Promise<any>;
-    _resolveLoad: (value: any) => void;
-    _rejectLoad: (reason?: any) => void;
-    _apiKey: string;
-    _loadInvoked: boolean;
-    _loaded: boolean;
-    _options: {};
+    constructor();
     /**
-     * Returns true if the map provider has been successfully loaded
-     * @type {boolean}
+     * @param controlEnabled - Whether the user can move and zoom the map
      */
-    get loaded(): boolean;
+    withControlEnabled(controlEnabled: boolean): MapOptions;
     /**
-     * @returns {module:@yext/components-maps~ProviderMap}
-     * @see module:@yext/components-maps~MapProviderOptions#withMapClass
+     * @param defaultCenter - The center on initial load and
+     *   when calling {@link Map#fitCoordinates} with an empty array
      */
-    getMapClass(): any;
+    withDefaultCenter(defaultCenter: Coordinate$1): MapOptions;
     /**
-     * @returns {module:@yext/components-maps~ProviderPin}
-     * @see module:@yext/components-maps~MapProviderOptions#withPinClass
+     * @param defaultZoom - The zoom on initial load and when calling {@link Map#fitCoordinates}
+     *   with an empty array
      */
-    getPinClass(): any;
+    withDefaultZoom(defaultZoom: number): MapOptions;
     /**
-     * @returns {string}
-     * @see module:@yext/components-maps~MapProviderOptions#withProviderName
+     * GENERATOR TODO Map legend not yet implemented
+     * @param legendPins - Pins used to construct the map legend
      */
-    getProviderName(): string;
+    withLegendPins(legendPins: MapPin[]): MapOptions;
     /**
-     * Call {@link module:@yext/components-maps~MapPinOptions~loadFunction MapPinOptions~loadFunction}
-     * and resolve or reject when loading succeeds or fails
-     * @async
-     * @param {string} [apiKey] Provider API key -- uses value from {@link module:@yext/components-maps~MapProvider#setLoadOptions MapProvider#setLoadOptions}
-     *   if not passed
-     * @param {Object} [options] Additional provider-specific options -- uses value from {@link module:@yext/components-maps~MapProvider#setLoadOptions MapProvider#setLoadOptions}
-     *   if not passed
+     * Padding is used by {@link Map#fitCoordinates}.
+     * Padding can either be constant values or funtions that return a padding value.
+     * See {@link Map#setPadding} for more information.
+     * @see {@link Map#setPadding}
      */
-    load(apiKey?: string | undefined, options?: Object | undefined): Promise<void>;
+    withPadding(padding: {
+        bottom: number | PaddingFunction;
+        left: number | PaddingFunction;
+        right: number | PaddingFunction;
+        top: number | PaddingFunction;
+    }): MapOptions;
+    withPanHandler(panHandler: PanHandler): MapOptions;
+    withPanStartHandler(panStartHandler: PanStartHandler): MapOptions;
     /**
-     * Resolves or rejects when the map provider has loaded successfully or unsuccessfully
-     * @async
+     * The {@link MapProvider} must be loaded before
+     * constructing the {@link Map}.
      */
-    ready(): Promise<void>;
+    withProvider(provider: MapProvider): MapOptions;
     /**
-     * Set the API key and provider options used on load. Does nothing if load was already called.
-     * @param {string} apiKey Provider API key
-     * @param {?Object} [options=null] Additional provider-specific options
+     * @param providerOptions - A free-form object used to set any additional provider-specific
+     *   options in the {@link ProviderMap}
+     */
+    withProviderOptions(providerOptions: object): MapOptions;
+    /**
+     * @param singlePinZoom - The zoom when calling {@link Map#fitCoordinates}
+     *   with an array containing one coordinate
+     */
+    withSinglePinZoom(singlePinZoom: number): MapOptions;
+    /**
+     * @param wrapper - The wrapper element that the map will be inserted into. The
+     *   existing contents of the element will be removed.
      */
-    setLoadOptions(apiKey: string, options?: Object | null | undefined): void;
+    withWrapper(wrapper: HTMLElement | null): MapOptions;
+    build(): Map$1;
+}
+/**
+ * An interactive map that supports various map providers, such as Google Maps and Mapbox, with a
+ * single API. Code written using this class functions approximately the same regardless of the map
+ * provider used. Any map provider can be supported via an instance of {@link MapProvider}.
+ */
+declare class Map$1 {
+    /**
+     * The {@link MapProvider} for the map must be loaded
+     * before calling this constructor.
+     */
+    _defaultCenter: Coordinate$1;
+    _defaultZoom: number;
+    _legendPins: MapPin[];
+    _padding: PaddingObject;
+    _provider: MapProvider | null;
+    _singlePinZoom: number;
+    _wrapper: HTMLElement | null;
+    _cachedBounds: GeoBounds | null;
+    _resolveIdle: () => void;
+    _resolveMoving: () => void;
+    _idlePromise: Promise<void>;
+    _panHandlerRunning: boolean;
+    _panStartHandlerRunning: boolean;
+    _currentBounds: GeoBounds;
+    _movingPromise?: Promise<void>;
+    _panHandler?: PanHandler;
+    _panStartHandler?: PanStartHandler;
+    _map: ProviderMap;
+    constructor(options: MapOptions);
+    /**
+     * Set the map bounds so that all the given coordinates are within the {@link padded}
+     * view.
+     * @param animated - Whether to transition smoothly to the new bounds
+     * @param maxZoom - The max zoom level after fitting. Uses {@link singlePinZoom}
+     *   by default.
+     */
+    fitCoordinates(coordinates: Coordinate$1[], animated?: boolean, maxZoom?: number): void;
+    /**
+     * Get the current visible region of the map. If the map is zoomed out to show multiple copies of
+     * the world, the longitude bounds will be outside [-180, 180) but the center will always be
+     * within [-180, 180).
+     */
+    getBounds(): GeoBounds;
+    /**
+     * @returns The center of the current visible region of
+     *   the map
+     */
+    getCenter(): Coordinate$1;
+    /**
+     * Intended for internal use only
+     * @returns The map's {@link ProviderMap}
+     *   instance
+     */
+    getProviderMap(): ProviderMap;
+    /**
+     * To standardize zoom for all providers, zoom level is calculated with this formula:
+     * zoom = log2(pixel width of equator) - 8.
+     * At zoom = 0, the entire world is 256 pixels wide.
+     * At zoom = 1, the entire world is 512 pixels wide.
+     * Zoom 2 → 1024 pixels, zoom 3 → 2056 pixels, etc.
+     * Negative and non-integer zoom levels are valid and follow the formula.
+     * @returns The current zoom level of the map
+     */
+    getZoom(): number;
+    /**
+     * Returns when the map is not moving.
+     * Use map.idle().then(callback) to run callback immediately if the map is currently idle or once
+     * the map becomes idle if it's not.
+     */
+    idle(): Promise<void>;
+    /**
+     * Returns when the map is moving.
+     * Use map.moving().then(callback) to run callback immediately if the map is currently moving or
+     * once the map starts moving if it's not.
+     */
+    moving(): Promise<void>;
+    /**
+     * @returns A {@link MapPinOptions}
+     *   instance with the same provider as this map
+     */
+    newPinOptions(): MapPinOptions;
+    /**
+     * Called when the map has finished moving, at most once per animation frame.
+     * Passes the current and previous bounds to the custom pan handler given by {@link MapOptions#withPanHandler}
+     */
+    panHandler(): void;
+    /**
+     * Called when the map has started moving, at most once per animation frame.
+     * Passes the current bounds to the custom pan handler given by {@link MapOptions#withPanStartHandler}
+     */
+    panStartHandler(): void;
+    /**
+     * @param bounds - bounds.ne: The northeast corner of the bounds -- must be convertible to {@link Coordinate}
+     * bounds.se: The southwest corner of the bounds -- must be convertible to {@link Coordinate}
+     * @param animated - Whether to transition smoothly to the new bounds
+     * @param padding - padding.bottom: Minimum number of pixels between the map's bottom edge and a pin
+     * padding.left: Minimum number of pixels between the map's left edge and a pin
+     * padding.right: Minimum number of pixels between the map's right edge and a pin
+     * padding.top: Minimum number of pixels between the map's top edge and a pin
+     */
+    setBounds({ ne, sw }: GeoBounds, animated?: boolean, padding?: {
+        bottom?: number | PaddingFunction;
+        left?: number | PaddingFunction;
+        right?: number | PaddingFunction;
+        top?: number | PaddingFunction;
+    }, maxZoom?: number): void;
+    /**
+     * @param coordinate - Must be convertible to {@link Coordinate}
+     * @param animated - Whether to transition smoothly to the new center
+     */
+    setCenter(coordinate: object, animated?: boolean): void;
+    /**
+     * Padding is used by {@link Map#fitCoordinates}.
+     * Padding can either be constant values or funtions that return a padding value.
+     * Constant values are good if the map should always have the same padding on every breakpoint.
+     * Functions are useful if the map should have different padding at different breakpoints/layouts.
+     * The function can check window.innerWidth or any other condition before returning a number.
+     * @param padding - padding.bottom: Minimum number of pixels between the map's bottom edge and a pin
+     * padding.left: Minimum number of pixels between the map's left edge and a pin
+     * padding.right: Minimum number of pixels between the map's right edge and a pin
+     * padding.top: Minimum number of pixels between the map's top edge and a pin
+     */
+    setPadding({ bottom, left, right, top, }: {
+        bottom?: number | PaddingFunction;
+        left?: number | PaddingFunction;
+        right?: number | PaddingFunction;
+        top?: number | PaddingFunction;
+    }): Map$1;
+    setPanHandler(panHandler: PanHandler): void;
+    setPanStartHandler(panStartHandler: PanStartHandler): void;
+    /**
+     * @param animated - Whether to transition smoothly to the new zoom
+     * @see Map#getZoom
+     */
+    setZoom(zoom: number, animated?: boolean): void;
+    /**
+     * @param center - Must be convertible to {@link Coordinate}
+     * @param animated - Whether to transition smoothly to the new bounds
+     * @see Map#setZoom
+     * @see Map#setCenter
+     */
+    setZoomCenter(zoom: number, center: Coordinate$1, animated?: boolean): void;
+    /**
+     * Set the map state to idle
+     */
+    _setIdle(): void;
+    /**
+     * Set the map state to moving
+     */
+    _setMoving(): void;
 }
 
 interface Coordinate {
@@ -1089,14 +1469,14 @@ interface MapProps {
     defaultCenter?: Coordinate;
     defaultZoom?: number;
     mapRef?: React__default.MutableRefObject<Map$1 | null>;
-    padding?: number | {
-        bottom: number | (() => number);
-        left: number | (() => number);
-        right: number | (() => number);
-        top: number | (() => number);
+    padding?: {
+        bottom: number | PaddingFunction;
+        left: number | PaddingFunction;
+        right: number | PaddingFunction;
+        top: number | PaddingFunction;
     };
-    panHandler?: (previousBounds: GeoBounds, currentBounds: GeoBounds) => void;
-    panStartHandler?: (currentBounds: GeoBounds) => void;
+    panHandler?: PanHandler;
+    panStartHandler?: PanStartHandler;
     provider?: MapProvider;
     providerOptions?: {
         [key: string]: any;
@@ -1534,31 +1914,33 @@ declare const Product: (document: Record<string, any>, schemaType?: string) => {
 type RTF2 = {
     json?: Record<string, any>;
 };
-type FAQ = {
+type FAQ = PlainTextFAQ | RichTextFAQ;
+type PlainTextFAQ = {
     question: string;
     answer: string;
-} | {
+};
+type RichTextFAQ = {
     question: string;
     answerV2: RTF2;
 };
 declare const FAQPage: (data: FAQ[]) => {
     "@context": string;
     "@type": string;
-    mainEntity: {
+    mainEntity: ({
         "@type": string;
         name: string;
         acceptedAnswer: {
             "@type": string;
             text: string;
         };
-    }[];
+    } | undefined)[];
 };
 
 type Location = {
     name?: string;
     address?: AddressType;
 };
-declare const AddressSchema: (address?: AddressType) => {
+declare const AddressSchema: (address?: AddressType) => false | {
     address: {
         "@type": string;
         streetAddress: string;
@@ -1567,8 +1949,8 @@ declare const AddressSchema: (address?: AddressType) => {
         postalCode: string;
         addressCountry: string;
     };
-} | undefined;
-declare const LocationSchema: (location?: Location) => {
+};
+declare const LocationSchema: (location?: Location) => false | {
     address?: {
         "@type": string;
         streetAddress: string;
@@ -1579,7 +1961,7 @@ declare const LocationSchema: (location?: Location) => {
     } | undefined;
     "@type": string;
     name: string | undefined;
-} | undefined;
+};
 
 declare const OpeningHoursSchema: (hours?: HoursType) => {
     openingHours?: undefined;
@@ -1595,7 +1977,7 @@ type Offer = {
     itemCondition?: string;
     availability?: string;
 };
-declare const OfferSchema: (offer?: Offer) => {
+declare const OfferSchema: (offer?: Offer) => false | {
     offers: {
         "@type": string;
         url: string | undefined;
@@ -1605,25 +1987,25 @@ declare const OfferSchema: (offer?: Offer) => {
         itemCondition: string | undefined;
         availability: string | undefined;
     };
-} | undefined;
+};
 
 type Organization = {
     name?: string;
     url?: string;
 };
-declare const PerformerSchema: (performers?: string[]) => {
+declare const PerformerSchema: (performers?: string[]) => false | {
     performer: {
         "@type": string;
         name: string;
     };
-} | undefined;
-declare const OrganizationSchema: (org?: Organization) => {
+};
+declare const OrganizationSchema: (org?: Organization) => false | {
     organizer: {
         "@type": string;
         name: string | undefined;
         url: string | undefined;
     };
-} | undefined;
+};
 
 type PhotoGallery = Photo[];
 type Photo = {
@@ -1634,9 +2016,9 @@ declare const PhotoGallerySchema: (gallery?: PhotoGallery) => {
 } | {
     image: string[];
 };
-declare const PhotoSchema: (photo?: Photo) => {
+declare const PhotoSchema: (photo?: Photo) => false | {
     image: string;
-} | undefined;
+};
 
 type Review = {
     ratingValue?: string;
@@ -1647,7 +2029,7 @@ type AggregateRating = {
     ratingValue?: string;
     reviewCount?: string;
 };
-declare const ReviewSchema: (review?: Review) => {
+declare const ReviewSchema: (review?: Review) => false | {
     review: {
         "@type": string;
         reviewRating: {
@@ -1660,7 +2042,7 @@ declare const ReviewSchema: (review?: Review) => {
             name: string | undefined;
         };
     };
-} | undefined;
+};
 declare const AggregateRatingSchema: (rating?: AggregateRating) => {
     aggregateRating: {
         "@type": string;
@@ -1669,34 +2051,16 @@ declare const AggregateRatingSchema: (rating?: AggregateRating) => {
     };
 } | undefined;
 
-/**
- * @type {module:@yext/components-maps~MapProvider}
- */
-declare const BaiduMaps: any;
+declare const BaiduMaps: MapProvider;
 
-/**
- * @type {module:@yext/components-maps~MapProvider}
- */
-declare const BingMaps: any;
+declare const BingMaps: MapProvider;
 
-/**
- * @type {module:@yext/components-maps~MapProvider}
- */
-declare const GoogleMaps: any;
+declare const GoogleMaps: MapProvider;
 
-/**
- * @type {module:@yext/components-maps~MapProvider}
- */
-declare const MapboxMaps: any;
+declare const MapboxMaps: MapProvider;
 
-/**
- * @type {module:@yext/components-maps~MapProvider}
- */
-declare const LeafletMaps: any;
+declare const LeafletMaps: MapProvider;
 
-/**
- * @type {module:@yext/components-maps~MapProvider}
- */
-declare const MapQuestMaps: any;
+declare const MapQuestMaps: MapProvider;
 
 export { Address, type AddressLine, type AddressLineProps, type AddressProps, AddressSchema, type AddressType, type AggregateRating, AggregateRatingSchema, Analytics, AnalyticsContext, AnalyticsProvider, AnalyticsScopeProvider, BaiduMaps, BaseSchema, BingMaps, type CTA, type CTAWithChildrenLinkProps, type CTAWithoutChildrenLinkProps, type ClusterTemplateProps, Clusterer, type ClustererContextType, type ClustererProps, type ComplexImageType, type Coordinate, Coordinate$1 as CoordinateClass, Day, type DayOfWeekNames, type DayType, type DirectionCoordinate, Event, FAQPage, type GetDirectionsConfig, GoogleMaps, type HREFLinkProps, type HolidayType, HoursStatus, HoursTable, type HoursTableDayData, type HoursTableProps, type HoursType, Image, type ImageLayout, ImageLayoutOption, type ImageProps, type ImageType, type IntervalType, LeafletMaps, LegacyRichText, LexicalRichText, type LexicalRichTextProps, Link, type LinkProps, type LinkType, LinkTypes, type ListingPublisher, ListingPublisherOption, type ListingType, LocalBusiness, type Location, LocationMap, type LocationMapProps, LocationSchema, Map, type MapContextType, type MapProps, type MapProvider$1 as MapProvider, MapProviderOption, MapQuestMaps, MapboxMaps, Marker, type MarkerProps, type Offer, OfferSchema, OpeningHoursSchema, type Organization, OrganizationSchema, PerformerSchema, type PhotoGallery, PhotoGallerySchema, PhotoSchema, type PinStoreType, Product, type Review, ReviewSchema, SchemaWrapper, type ThumbnailType, type WeekType, debuggingParamDetected, getDirections, useAnalytics, useClusterContext, useIdentify, useMapContext, usePageView, useScope, useTrack };