AppModule

AppService

B2BModule

B2BService

BackInStockAPI

BackInStockConstants

Back-In-Stock module constants for Widget Integration.

This injectable class contains all constant values used throughout the back-in-stock widget, including CSS class names, element IDs, CSS selectors, and configuration defaults.

BackInStockController

BackInStockModule

BackInStockService

CartAPI

CartController

Cart controller managing UI interactions, modal display, and cart operations

This controller provides extensive customization capabilities for Technical Support teams through protected extension points. All timing, selectors, translations, and behavior can be customized per-shop without modifying core code.

## Key Extension Points

### Button State Management - updateButtonState() - Customize button UI updates (text, disabled state, styling) - getButtonStateTranslations() - Override button text for different locales - getButtonSuccessResetDelay() - Control how long "Added!" shows (default: 500ms) - getButtonFailureResetDelay() - Control error state duration (default: 300ms)

### Cart Opening Behavior - shouldOpenCartAfterAdd() - Control when cart opens after add-to-cart - openCart() - Customize cart opening logic and animations - closeCart() - Customize cart closing and cleanup

### Theme Integration - getCartEnabledBodyClass() - Override body class for cart enabled state - getModalId() - Customize modal element ID - getModalOpenBodyClass() - Override body class when modal is open - getButtonTextSelectors() - Add custom theme button selectors

### Accessibility & Focus Management - setupWCAGAccessibility() - Extend WCAG compliance features - saveFocusElementBeforeCart() - Customize focus saving logic - restoreFocusAfterCart() - Customize focus restoration logic

## Common Customization Patterns

CartDrawerRecommendationConstants

Cart Drawer Recommendation (RCU) Constants.

## Customization

window.boostWidgetIntegration.extend('CartDrawerRecommendationConstants', (Base) => {
  return class extends Base {
    get SELECTORS() {
      return { ...super.SELECTORS, CART_MODAL: '#custom-cart-drawer' };
    }
  };
});

CartDrawerRecommendationController

Controller for managing recommendation widget interactions within the cart drawer.

NOTE: This controller does NOT extend RecommendationWidgetController to avoid circular dependency (RecommendationModule imports CartModule). Instead, it implements its own formatPrice() method using the same logic as the base controller.

This controller handles user interactions with recommendation products that are rendered by the backend cart template. The template renders the recommendation widget using data from CartService.getCartDrawerRecommendationData().

## Key Responsibilities - Handles "Add to Cart" button clicks from recommendation products - Manages native CSS/JS carousel (not Slick) for recommendation products - Dispatches cart updated events after adding products - Manages event listeners for cart drawer lifecycle

## Extension Points - getAddToCartButtonSelector() - Customize the Add to Cart button selector - getRecommendationContainerSelector() - Customize the recommendation container selector - handleAddToCart() - Customize add to cart behavior - afterCartDrawerAddToCart() - Add custom post-add-to-cart logic - getSlidesPerView() - Customize number of slides per view based on cart style - getHighlightDuration() - Customize success/error message display duration - getErrorMessage() - Customize error message extraction for shop-specific errors - formatPrice() - Customize price formatting for variant price updates - getAddingButtonText() / getAddedButtonText() / getFailedButtonText() / getDefaultAddButtonText() / getSuccessMessageText() - Customize button and message strings for localization

CartDrawerRecommendationLifecycle

CartDrawerRecommendationService

Service for preparing cart-drawer recommendation data.

This service acts as a **shared renderer** that bridges RecommendationService to consumers (CartService for Phase 1, ThemeAppBlock for Phase 2).

## Architecture

RecommendationService (core)
        ↓
CartDrawerRecommendationService (shared renderer)
        ↓
CartService

## Key Responsibilities - Check if cart-drawer recommendation is enabled - Fetch recommendation products via RecommendationService - Format products/variants for template rendering (price formatting) - Provide data structure ready for Liquid template

## Extension Points for TS Team - formatPrice() - Customize price formatting - formatProductsForTemplate() - Customize product transformation - formatVariantsForTemplate() - Customize variant transformation - fetchRecommendationProducts() - Add custom filtering/sorting

CartModule

Cart module managing cart functionality via Widget Integration framework

This module orchestrates cart operations including: - Cart modal display and interactions - Add to cart functionality - Cart state management - Theme-specific cart icon handling

Technical Support teams can extend this module for shop-specific customization: - Override block listener setup via - Customize block initialization via - Add custom error handling via

CartSelectors

Cart selectors managing theme-specific cart icon configurations

Provides cart icon selectors and update actions for 30+ Shopify themes including: - Dawn, Debut, Sense, Craft, Refresh, Studio, Taste, Ride, Crave - Prestige, Empire, Impulse, Motion, Flex, Flow, Venue, Warehouse - Turbo, Testament, Venture, Symetry, Superstore, Icon, Ella - BlockShop, ColorBlock, Broadcast, Focal, Expanse - And more custom themes

Technical Support teams can: - Add custom theme configurations via window.boostWidgetIntegrationConfig - Override theme detection logic - Customize cart count update behavior

CartService

Cart service managing cart operations and business logic

Provides cart functionality including: - Adding products to cart (single or multi-product) - Cart quantity management with queue to prevent race conditions - Cart modal rendering with template customization - Post-add-to-cart action handling (redirect, drawer, etc.) - Cart backup/restore functionality

Extension points for Technical Support customization: - - Custom redirect/drawer behavior after adding items - - Custom cart page redirect logic - - Shop-specific cart rendering defaults - - Custom cart item formatting and enrichment - - Custom cart template loading - - Custom validation rules for cart items - - Add shop-specific data to cart responses - - Custom error handling and user feedback

CombinedProductListingsAPI

CombinedProductListingsController

CombinedProductListingsModule

CombinedProductListingsService

CountdownTimerAPI

API service for fetching countdown timer campaigns from the backend.

Resolves the current page context (product/cart) and fetches the most relevant active campaign. The backend handles scope filtering, country targeting, and time-window validation — this class only needs to identify the page scope and make the request.

CountdownTimerController

Controller that manages the countdown timer widget lifecycle.

Handles the full flow: fetching the active campaign from the API, rendering the timer into the DOM, ticking every second, and handling expiration behavior (repeat, disable, or freeze at 00:00:00).

CountdownTimerModule

Module for the countdown timer widget.

Registers CountdownTimerAPI, CountdownTimerController, and as providers and listens for countdownTimer TAE blocks to bootstrap a controller per block instance.

CustomizationCompatibility

Service for maintaining backward compatibility with legacy customization patterns.

This service enables shops that used legacy customization.afterRender hooks in TAE configuration to continue working without code changes. It executes both general and block-specific afterRender callbacks after widget rendering.

FilterAPI

API service for handling filter widget requests to the Boost filter engine.

This service provides functionality for fetching filtered product results from the Boost API. It manages request construction, caching, and response processing through extensible methods that allow customization for shop-specific requirements.

FilterController

Main controller for managing filter functionality in collection and search pages.

This controller orchestrates all filter-related operations including: - Filter tree rendering and state management - Product list updates and pagination - Event handling for user interactions - Price transformation and currency formatting - Mobile and desktop responsive behaviors - Integration with cart, bundles, and recommendations

The class is designed to be extended by Technical Support teams for shop-specific customizations. Protected methods provide clear extension points for modifying filter behavior, product rendering, and UI interactions.

FilterFormatHelper

FilterHandler

Handler service for filter widget user interactions and UI state management.

This service orchestrates all user interaction handlers for the filter system including product clicks, sorting, pagination, view switching, and filter tree interactions. It acts as the central event router that processes DOM events and translates them into filter state changes and custom events. Can be extended by Technical Support teams to customize interaction behaviors for shop-specific requirements.

FilterHelper

Central helper service providing utility functions for the filter module.

This service acts as a unified facade for filter-related operations, delegating to specialized helper services (URL, Format, Storage, Validation) while also providing core utilities for JSON parsing, debouncing, event management, template handling, and product URL construction. It can be extended by Technical Support teams to customize filter behaviors, add shop-specific logic, or override default implementations.

FilterModule

Filter widget module for Widget Integration.

Manages the initialization, registration, and lifecycle of filter widgets on collection and search pages. Handles widget connection with TAE framework and dependency injection for all filter-related services.

FilterRender

Rendering service for filter widget UI components.

Manages all DOM rendering operations for the filter widget, including filter options, refine-by tags, view more buttons, collection headers, and mobile/desktop layouts. Coordinates with FilterStore for state management and FilterHelper for utilities.

FilterSearchPageAPI

FilterSearchPageController

FilterSearchPageService

FilterService

Core business logic service for filter widget operations.

Orchestrates filter API calls, state management, URL handling, pagination, and filter option processing. Coordinates between FilterAPI, FilterStore, and various helper services to provide complete filter functionality.

FilterStorageHelper

Storage helper for filter module operations.

Provides a unified interface for localStorage and sessionStorage operations with built-in error handling, type safety, and JSON serialization. Manages filter-related storage including collection data, pagination state, and temporary filter selections.

FilterStore

Store for managing filter state, URL parameter mappings, and filter cache.

This store manages filter-related state including URL parameter shortening, request caching, and state change notifications. It can be extended by Technical Support teams to customize filter behavior for specific shops.

FilterTranslationService

Service for managing filter translations and applying them to filter UI elements.

This service handles translation of filter options, labels, and UI text using the app's translation configuration. It supports nested translation keys, template variable replacement, and automatic XSS sanitization. It can be extended by Technical Support teams to customize translation behavior for specific shops or languages.

FilterUrlHelper

URL Management Helper for Filter Module

Manages all URL and query parameter operations for the filter system, including parameter get/set/delete operations, history management, and URL shortening schemes.

This helper can be extended by Technical Support teams to customize URL handling for specific shops, including custom parameter formats, separators, and history behavior.

FilterValidationHelper

Validation Helper for Filter Module

Provides comprehensive validation and sanitization utilities for the filter system, including XSS detection, input validation, and data sanitization for secure filter operations.

This helper can be extended by Technical Support teams to customize validation rules for specific shops, including custom XSS patterns, allowed characters, or sanitization behavior.

InstantSearchAPI

API service for instant search operations.

Technical Support teams can extend this service for custom API behavior:

InstantSearchController

Controller for instant search UI interactions.

InstantSearchModule

Instant Search Widget Module

Provides a unified, framework-based instant search system for Shopify themes.

**Features**: - Search-as-you-type with debounced API requests - Multiple display styles (dropdown, full-width overlay) - 20+ theme auto-detection and integration - Full keyboard accessibility (WCAG compliant) - Recent searches management - Custom events for extensibility

**Migration from Legacy**:

| Legacy | New Module | |-------------------------------------|-------------------------------------| | handleInstantSearchWidget(context) | window.boostISWModule.initISWWithContext(settings) | | Global functions with context param | DI-based services | | Hard-coded selectors | Theme config map | | Inline event handling | Controller with state management |

**Technical Support Extension**:

window.boostWidgetIntegration.extend('InstantSearchModule', (InstantSearchModule) => {
  return class CustomISWModule extends InstantSearchModule {
    async onInitBlock(block) {
      // Add custom tracking
      await super.onInitBlock(block);
    }
  };
});

InstantSearchSelectors

Service for theme detection and selector management.

Technical Support teams can extend this service for custom themes:

InstantSearchService

Service for instant search business logic.

Technical Support teams can extend this service for custom search behavior:

PlatformLoader

PlatformModule

PositionService

Service for calculating ISW dropdown position.

Technical Support teams can extend this service for custom positioning:

PredictiveBundleAPI

Fetches predictive bundle data and applies shop-specific request enrichment.

Override request-building methods to add custom segmentation, localization, or analytics parameters for Technical Support customizations.

PredictiveBundleConstants

PredictiveBundleController

Manages predictive bundle rendering, modal behavior, and interaction handling.

Override public methods in this controller to customize modal opening behavior, rendering hooks, or interaction responses without replacing the full module.

PredictiveBundleModel

PredictiveBundleModule

Wires predictive bundle blocks into TAE and bridges the legacy global open event.

Override this module to customize block discovery, controller connection, or validation of externally dispatched bundle payloads before the modal opens.

PredictiveBundleService

Provides predictive bundle business logic, pricing calculations, and template access.

Most shop-specific customization should happen by extending this service instead of editing controller flows directly.

PredictiveBundleStateService

Stores transient predictive bundle UI state shared across bundle surfaces.

Keep overrides lightweight and prefer clearing state when a custom flow no longer needs cached bundle data.

PreOrderAPI

PreOrderController

PreOrderModule

PreOrderService

ProductAPI

API service for fetching product details used in Quick View modal.

Returns pre-rendered HTML from server including product images, variant swatches, price display, and add to cart functionality.

ProductController

ProductModel

Product Item Model - Data model for product item state

ProductModule

ProductService

ProductSwatchService

QuickAddToCartController

QuickViewController

QuickViewModule

RecentlyViewedProductModule

RecentlyViewedProductService

RecentSearchService

Service for managing recent searches in localStorage.

Technical Support teams can extend this service for custom storage strategies:

RecommendationAnalytic

Service for handling recommendation widget analytics and tracking data storage.

This service manages the persistence of recommendation widget tracking data to localStorage, enabling analytics and tracking of user interactions with recommendation widgets. It provides customizable storage key generation and error handling that can be extended by Technical Support teams for shop-specific requirements.

RecommendationAPI

API service for handling recommendation widget requests to the Boost recommendation engine.

This service extends BoostAPI to provide specialized functionality for fetching product recommendations from the Boost API. It manages request construction through extensible protected methods that allow Technical Support teams to customize query parameters and body payloads for shop-specific requirements.

The service uses a functional pipeline approach to transform request parameters, applying currency settings and B2B configurations automatically while allowing additional customizations through method overrides.

RecommendationModel

Data model for recommendation widgets containing configuration and product data.

RecommendationModule

RecommendationService

Service for managing recommendation widgets and their data.

RecommendationWidgetController

Controller for managing recommendation widget lifecycle, rendering, and carousel functionality.

This controller orchestrates the complete lifecycle of recommendation widgets, from data fetching to rendering and carousel initialization. It provides numerous extension points for Technical Support teams to customize widget behavior for specific shops without modifying core code.

ShopifyPlatform

ShopifyRouter

StickyController

StickyService

TemplateAPI

TemplateModule

TierDiscountAPI

TierDiscountModel

TierDiscountModule

Module for tier discount bundle widgets.

Integrates tier discount functionality into the TAE framework, providing: - Automatic widget initialization from Shopify blocks - Dependency injection for all services - Lazy loading of widgets - Extensibility for shop-specific customizations

Technical Support teams can extend this module to customize initialization or add shop-specific services to the dependency injection container.

TierDiscountService

Service for managing tier discount bundle business logic.

Provides methods for: - Calculating tier achievements and discounts - Managing bundle cart state - Processing product selections - Validating bundle configurations

Technical Support teams can extend this class to customize business logic for specific shops without modifying core functionality.

TierDiscountWidgetController

VolumeBundleAPI

VolumeBundleConstants

VolumeBundleController

VolumeBundleEventService

VolumeBundleModel

VolumeBundleModule

VolumeBundleService

BoostAPI

CartErrorType

Cart error types for categorization and handling

Used to categorize cart errors for logging, analytics, and customized error handling by Technical Support teams.

CartUpdateOperation

Cart update operation types

Defines the types of cart update operations for queue management and conflict prevention.

addToCart(_context, params)

buildProductDetailUrlWithLocale(_context)

closeQuickAddToCart(_context, target)

closeSuggestion(_context, _input)

dynamicBundleData(_context, bundle, _optionData, action, _target)

focusOnSearchElements()

formatPrice(context, price)

getAppModuleRef()

getCartSelectorAndUpdateAction()

getDynamicBundleSettingsByWidgetId(_context, widgetId)

getFilterSettings()

getInstance(module)

getOnClickRecentSearches(maxRecentSearch)

getVolumeBundleSettingsByWidgetId(_context, _widgetId)

handleClickEmbeddedBundle(bundle)

handleClickOutsideMiniPopup(_context, target)

handleClickProductItem(_context, _action, target)

handleClickVolumeBundle(_context, target)

handleProductSwatches()

handleQuickAddToCartSelectOption(_context, item, target)

handleRecentSearchForSuggestionTerm(event)

handleSearchInputChange(_context, event, input)

initDynamicBundle(_context)

initVolumeBundle(_context)

injectTierDiscountForSearchPage()

Initializes tier discount widget on search page Uses static method from TierDiscountModule to access DI container

isValidateDynamicBundle(context)

onCloseSuggestion(_context, _input)

onOpenSuggestion(_context, input)

openSuggestion(_context, input)

quickAddToCart(_context, item, target)

quickView(_context, action, target)

reinitializeTierDiscountForSearchPage()

Resets initialization guards and re-injects the tier discount widget. Called after each filter/sort/pagination update when tiered bundle is the latest, ensuring the widget always reflects current filter results.

renderPredictiveBlocksForProductPage(_context, productId)

renderRecommendationForSearchPage(_context)

renderVolumeBlocksForProductPage(_context, productId)

renderVolumeBundleForSearchPage(_context)

resetButtonListener(input, thisResetButton)

searchButtonListener(_context, _event, input)

searchInputKeydownListener(_context, event, input)

searchInputListener(_context, _event, input)

setOnClickRecentSearches(item, _extraParam, _scope)

setUniformProductImageHeight(_context, mobileItemsPerRow, desktopItemsPerRow, mobileBreakPoint, tabletPortraitBreakPoint, tabletPortraitItemsPerRow)

styleBottomCTALayout8(_context)

transformProductPrice(_context)

trapFocusInBundle(bundleWrapper, _context, isModal)

volumeBundleData(_context, bundle, _optionData, _action, _target)

AddedItem

AddedVariant

AdditionalElementExtendAppConfig

AdditionalElementSettings

AddToCartItem

Configuration for cart item addition

Supports both single product and multi-product addition patterns. Can be extended with custom properties for shop-specific needs.

AddToCartResult

Result of add to cart operation

Provides structured response for cart operations with success/error status. Includes optional response data and error messages.

ApplicationConfig

AppSettingsExtendedConfig

AppTranslation

AssetFilesLoaderExtendedAppConfig

B2BExtendedConfig

BackInStockExtendAppConfig

BackInStockProduct

BackInStockProductQueryParams

BackInStockSettings

BackInStockState

BackInStockSubscriptionData

BackInStockSubscriptionResponse

BackInStockTemplateSettings

BlockingMetrics

Main thread blocking metrics

BoostStickyOptions

BuildCartPayloadOptions

BundleableProduct

BundleableSelectedOption

BundleCartItem

BundleDiscount

BundlePriceResult

BundleProduct

BundleQueryParams

BundleSelectedOption

BundleSessionData

BundleUpdateData

CachedSuggestionData

Structure for cached suggestion data.

CarouselState

Carousel state for tracking slide position and configuration. Used internally by the controller to manage the native CSS/JS carousel.

CartAddItem

Interface for cart item to be added

CartAttributes

CartChangeResponse

Interface for cart change response

CartDrawerRecommendationTemplateData

Template data for cart-drawer recommendation rendering. This is the primary data structure passed to the cart template and received by custom renderRecommendationWidget() overrides.

CartErrorContext

Cart error context for debugging and logging

Provides additional context about errors for better debugging and error tracking in production.

CartExtendedConfig

CartModalData

Rendered cart modal data

Contains the rendered HTML and metadata for displaying the cart.

CartRenderConfig

Configuration for cart rendering

Controls how the cart is displayed to users including style, currency formatting, and other display preferences.

CartResponse

CartSettings

CartState

CartUpdateRequest

Cart update request for queue management

Used internally to queue cart updates and prevent race conditions.

CollectionFilterExtendedConfig

CollectionResponseType

Collection information with label/value structure for UI display. Used in rule conditions and consequences for collection filters.

CollectionsBlock

CombinedListingHooks

CombinedListingState

CombinedParentVariant

CombinedProductData

CombinedQuickViewUIHooks

ConditionType

Condition type for rule-based recommendations. Defines the "IF" part of a rule - what criteria must be met.

ContainerInternals

ContainerOptions

CountdownCampaign

Campaign data as returned by sip-api GET /bc-sf-filter/countdown-timer. Shape matches Redis hash field in bc-sf-filter:{tenantId}:countdown_timer.

CountdownGeneralSettings

General display and interaction settings for the countdown timer.

CountdownStyleSettings

Style settings from BE.

CountdownTimerAPIResponse

API response shape from GET /bc-sf-filter/countdown-timer.

CountdownTimerLabels

Timer labels from BE (singular keys)

CountdownTimerSettings

Timer settings nested object from BE.

CountdownTimerTemplateData

Data passed to Liquid template for rendering.

Country

CurrentAppIntegration

CustomizeEmail

DefaultSuggestionData

Default suggestion data built on initialization.

**Legacy**: Built in buildDefaultDataSuggestion() function **New**: Typed interface for the default data structure

DiscountedPriceResult

DOMActionContext

DOMActionDefinition

DragState

Drag state for tracking touch/mouse drag interactions in the native carousel.

EnhancedContainerOptions

EnsureModalSurfaceOptions

EventPayload

Base payload structure for filter events.

Contains the event key, new value, and optionally the previous value for tracking state transitions.

ExtendedBoostStickyOptions

ExtendedTierDiscountModelProperties

ExtraFeatures

FactoryProviderDef

FallbackExtendedAppConfig

FeaturedImage

FilterControllerToggleAction

FilterRenderToggleAction

FilterSettings

FilterStyle

FocusedElementRef

FocusTrapOptions

FormatPriceParams

FormattedPriceResult

Formatted price result

FormattedProduct

Product formatted for template rendering. Primary values (price_min, etc.) are formatted strings for direct display. Raw numeric values are available with _raw suffix.

FormattedVariant

Variant formatted for template rendering. Primary values (price, compare_at_price) are formatted strings for direct display. Raw numeric values are available with _raw suffix.

GeneralSettings

Gorgias

HorizontalToolbarStickySelectors

HtmlTemplate

HTTPError

HTTPRequestConfig

HTTPResponse

HTTPServiceConfig

InterceptorManager

IPerformanceTracker

Performance tracker interface

IStickyProps

ISWRenderedEventDetail

Payload for boost-sd-isw-rendered custom event.

ISWState

Internal state management for the ISW controller.

**Legacy**: State was managed via global variables (keyboardNavIndex, currentSearch) **New**: Encapsulated in ISWState interface with proper typing

JavaScriptMetrics

JavaScript execution timing metrics

LoadModuleOptions

Options for dynamically loading modules via loadModule()

MemoryMetrics

Memory consumption metrics

ModalSurface

ModuleClass

ModuleMetadata

ModuleRef

MostPopularProducts

NormalizedBoostStickyOptions

NotificationSettings

OnApplicationBootstrap

OpenISWEventDetail

Payload for boost-sd-open-isw custom event.

OptionsWithValue

OptionsWithValues

Options with values for variant selection

PagesBlock

PerformanceIssue

Performance issue with severity and recommendations

PerformanceMeasurement

Performance measurement entry for tracking individual operations

PerformanceMetrics

Performance metrics and timing data

PerformanceReport

Performance report containing analysis and recommendations

PerformanceReportBreakdown

Detailed breakdown section of performance report

PerformanceReportSummary

Summary section of performance report

PerformanceTrackerOptions

Configuration options for performance tracking

PhoneDropdownState

Platform

PlatformRouter

PositionConfig

Position configuration for dropdown styles.

**Legacy**: Calculated inline in calcPositionSuggestionResult() **New**: Dedicated PositionService with typed config

PredictiveBundleControllerProps

PredictiveBundleControllerState

PredictiveBundleData

PredictiveBundleDefaultSettings

PredictiveBundleExtendedAppConfig

PredictiveBundleModelProperties

PredictiveBundleWidgetDesignSettings

PreOrderCartItem

Add to cart payload for pre-order items

PreOrderData

Pre-order data attached to a variant

PreOrderProductData

Pre-order product data

PreOrderSellingPlan

Selling plan configuration for pre-orders

PreOrderSettings

Pre-order settings from variant configuration

PreOrderState

PreOrderUIElements

UI elements for pre-order display

PreOrderVariant

Variant with pre-order information

PriceDisplaySettings

Price display settings from theme configuration

PriceFormatSettings

Price formatting settings from theme configuration.

PriceInfo

Price calculation result

PriceRenderParams

Parameters for price HTML generation

PriceTransformContext

Price transformation context with DOM and settings

ProcessedCartItem

Processed cart item ready for template rendering

Extends the base Product type with formatted display fields and filtered options. Used by cart templates for rendering.

ProductData

Product data structure from data-product attribute

ProductDataFromDOM

Product data extracted from DOM element

ProductImage

Represents a product image with position information

ProductItemTranslation

ProductOption

ProductPriceDisplaySettings

Price display settings from theme configuration

ProductResponseType

Product information in simplified format for rule conditions and consequences. Used when backend transforms product IDs into UI-friendly format.

ProductsBlock

ProductSuggestion

ProductUrlOptions

ProductVariant

QuantityRule

QuickAddToCartItem

Quick Add to Cart item payload

QuickViewAction

Quick View action payload

QuickViewProductData

QuickViewState

QuickViewTemplateParams

Quick View template params for API

RangeSliderContext

Shared context object passed between range slider helper methods.

Collects all DOM references, computed settings, and mutable slider state so that each helper function has a single, explicit parameter instead of relying on shared closure variables.

RawRecommendationProduct

Raw product data from Recommendation API before formatting. Note: Prices are in the store's currency unit (e.g., 19.99 for $19.99, 100 for 100 VND), NOT in cents like Shopify Cart API.

RawRecommendationVariant

Raw variant data from Recommendation API before formatting. Note: Prices are in the store's currency unit (e.g., 19.99 for $19.99, 100 for 100 VND), NOT in cents like Shopify Cart API.

RecentSearch

RecentSearchItem

Recent search item structure.

**Legacy**: Stored as { title, extraParam, scope } **New**: Same structure but properly typed

RecommendationModelProperties

RenderingMetrics

Rendering performance metrics

RequestIdleCallback

RequestInterceptor

ResolveOptions

ResponseInterceptor

Reviewsio

RuleGroupType

Rule group combining conditions and consequences. Represents a complete rule: IF conditions THEN show consequences.

SearchBoxOnclick

SearchBoxOnClickSettings

Search box on-click configuration from admin settings.

SearchEmptyResultMessages

SearchEventDetail

Payload for boost-sd-search custom event.

SearchExtendedAppConfig

SearchPanelBlocks

SearchSettings

Search settings from admin configuration.

**Legacy**: Retrieved via getSearchSettings(context) utility **New**: Same data but with full TypeScript interface

SearchTermSuggestion

SearchTermSuggestions

SearchTips

SelectedOption

SellingPlanAllocation

Selling plan allocation from Shopify cart item

SEOEnhancementExtendedAppConfig

ShippingUpdateEmail

ShopifyCartItemWithSellingPlan

Shopify cart item with selling plan

ShopifyMetafieldExtendedConfig

SignalOptions

SimplifiedIntegrationExtendAppConfig

SlickInstance

Slick carousel instance interface for type-safe method calls.

Provides type definitions for interacting with an initialized Slick carousel. Represents the jQuery plugin instance returned by $('.element').slick().

SlickOptions

Slick carousel configuration options.

Defines the behavior and appearance of the Slick carousel used for recommendation widgets with carousel layout. For complete options reference, see: https://kenwheeler.github.io/slick/

StackingContextOriginalStyles

StickyConfig

StickyOriginalStyles

StickyOverrideConfig

StickyServiceState

SuggestionBlock

Suggestion block configuration from admin settings.

SuggestionBlockItem

SuggestionBundle

Bundle information returned from the suggestion API.

SuggestionCollection

Collection item returned from the suggestion API.

SuggestionNoResult

SuggestionNoResultSettings

No result fallback configuration from admin settings.

SuggestionPage

Page item returned from the suggestion API.

SuggestionRequestParams

Parameters for suggestion API request.

SuggestionResponse

Response from the suggestion search API.

**Legacy**: Untyped object returned from getSuggestionSearch() **New**: Fully typed interface with JSDoc comments

SwatchConfig

SwatchOptionEventParams

SwatchSettings

Swatch settings from filter configuration

TemplateCTA

CTA data for template rendering

TemplateManagementExtendedAppConfig

TemplateTimerLabels

Labels for template rendering (plural keys)

ThemeCartConfig

ThemeSearchConfig

Theme-specific search configuration.

**Legacy**: Hard-coded selectors scattered in index.js **New**: Configurable per-theme with extensibility via window config

TierDiscount

TierDiscountBundle

TierDiscountDefaultSettings

TierDiscountModelProperties

TierDiscountProduct

TierDiscountProductImage

TierDiscountRule

TierDiscountTranslation

TierDiscountWidgetControllerProps

TierDiscountWidgetControllerState

TierDiscountWidgetDesignSettings

TimeRemaining

TypeProvider

ValueProviderDef

VariantSelection

Variant selection state

VariantSelectionState

VolumeBundleCartItem

VolumeBundleControllerProps

VolumeBundleControllerState

VolumeBundleData

VolumeBundleDefaultSettings

VolumeBundleDiscount

VolumeBundleDiscountedPriceResult

VolumeBundleDropdownOptions

VolumeBundleEventPayload

VolumeBundleFormatPriceParams

VolumeBundleModelProperties

VolumeBundleOption

VolumeBundleProduct

VolumeBundleSelectedOption

VolumeBundleSessionData

VolumeBundleWidgetDesignSettings

WatermarkSettings

WidgetDesignSettings

WidgetInfo

API_ACTION_TYPE

API action types for different filter widget operations.

Categorizes the type of API request being made for analytics and routing.

ATTR_VALUE

Common HTML attribute values used in filter widget.

Pre-defined values for standard attributes to ensure consistency.

BEHAVIOR_TYPE

Pagination behavior types for filter API requests.

Defines how new results should be integrated with existing content when paginating.

BOOST_SD_COLLECTION_ID_KEY

Storage key for current collection ID in session storage.

Stores the active collection ID to maintain state across page navigations and filter operations.

BOOST_SD_COLLECTION_TAGS_KEY

Storage key for current collection tags in session storage.

Stores collection tags to support tag-based filtering within collections.

BOUNDARY_SELECTORS

BundleEventProvider

COLLAPSE_STATE

Storage key for filter collapse state.

Stores which filter options are expanded or collapsed.

COLLECTION_ALL_STORAGE_KEY

Storage key for tracking the "All Products" collection ID.

Used to store the special collection ID that represents all products in local storage for session persistence.

COLLECTION_SELECTED

Storage key for currently selected collection.

Stores the active collection identifier.

CSS_CLASS

Standard CSS class names used in filter widget styling.

Contains reusable class names for common UI states and components. Technical Support teams can reference these when adding custom styles.

DEFAULT_SEPARATOR

Default separator for joining multiple filter values in URLs.

Used when constructing URL parameters with multiple selected values (e.g., "red,blue,green" for color filters).

DEFAULTS

DOM_EVENTS

Static list of DOM event names used for XSS detection.

Contains 100+ DOM event handler names that could be exploited in XSS attacks. This array is used to build the EVENT_REGEX pattern for comprehensive security scanning.

DOM_SELECTOR

CSS selectors for filter widget DOM elements.

Pre-defined selectors for querying filter widget elements in the DOM. Technical Support teams can use these for custom DOM manipulation.

EMAIL_REGEX

Cached regex patterns for validation.

Pre-compiled regular expressions for common validation tasks, shared across the filter module for optimal performance.

EVENT_NAMES

Standard event names used throughout the filter widget.

These constants define all available events for filter state changes, user interactions, and UI updates. Technical Support teams can listen to these events to hook into filter behavior.

EVENT_REGEX

Cached regex for DOM event detection.

Pre-compiled regular expression pattern built from the DOM_EVENTS array. Used by FilterValidationHelper for efficient XSS pattern detection without recompiling the regex on every validation call.

FILTER_DESKTOP_WRAPPER_SELECTOR

CSS selector for desktop filter tree wrapper element.

Targets the left sidebar container for desktop filter display.

FILTER_KEY_PREFIX

Prefix for all Boost filter URL parameters.

All filter parameters in the URL start with this prefix to avoid conflicts with other query parameters (e.g., "pf_st_color", "pf_t_vendor").

FILTER_MOBILE_BUTTON_BACK_CLASS

FILTER_MOBILE_BUTTON_BACK

FILTER_MOBILE_BUTTON_CLOSE_CLASS

FILTER_MOBILE_BUTTON_CLOSE

FILTER_MOBILE_BUTTON_HIDDEN

FILTER_MOBILE_FULL_HEIGHT_CLASS

CSS class for full-height filter option wrapper on mobile.

Applied to filter option containers that should take full viewport height.

FILTER_MOBILE_FULL_HEIGHT_SELECTOR

CSS selector combining full-height class for mobile filter wrapper.

FILTER_MOBILE_ICON_SELECTOR

FILTER_MOBILE_WRAPPER_SELECTOR

CSS selector for mobile filter tree wrapper element.

Targets the main container for the mobile filter tree overlay.

FILTER_OPTION_CONTENT_INNER_SCROLL_BAR

FILTER_OPTION_CONTENT_INNER

FILTER_OPTION_DISPLAY_TYPE

Filter option display type variants.

Defines how filter options are visually rendered in the UI. Each display type has different HTML structure and styling requirements.

FILTER_OPTION_ITEM_WRAPPER_COLLAPSED_CLASS

FILTER_OPTION_ITEM_WRAPPER_HIDDEN_CLASS

FILTER_OPTION_SEARCH_OPTION_SELECTOR

FILTER_OPTION_SELECTOR

FILTER_OPTION_TITLE_OPENING_CLASS

FILTER_OPTION_TYPE

Available filter option types.

Defines all supported filter types in the filter widget. Each type has specific behavior, display format, and data structure requirements.

FILTER_TAG_KEY

URL parameter key for tag filters.

The query parameter name used for tag-based filtering (e.g., "?pf_tag=summer").

FILTER_TREE_MOBILE_BUTTON_CLEAR

FILTER_TREE_MOBILE_TOOL_BAR

FILTER_TREE_RESET_DELAY

FILTER_TREE_STATE_KEY

Filter tree UI state storage keys.

Keys used to persist filter tree open/closed states and focus information in session storage for consistent user experience across page loads.

FILTER_TREE_TOGGLE_BUTTON_SELECTOR

HEADER_SELECTORS

HEX_COLOR_REGEX

HTML_ATTR

HTML attribute names used in filter widget elements.

Standard attribute names for accessibility, data storage, and behavior.

INFINITE_SCROLL_START_PAGE

Storage key for the starting page of an infinite-scroll / load-more session.

Used by trackSelectedProductPage to calculate the correct absolute page offset when the user navigates back after scrolling through multiple pages.

INITIAL_PAGE

Storage key for tracking the initial page number.

Stores the starting page when pagination is used, allowing reset to initial state.

INITIAL_SCALE

Initial scale factor for zoom animations.

Starting scale value for image or element zoom effects.

KEY_DYNAMIC_BUNDLE_DATA_SESSION

KEYS

Keyboard keys that trigger filter option selection.

Array of key values that should activate filter options when focused, supporting keyboard accessibility (Enter and Space).

LIMIT_FIRST_LOAD

LIMIT_SETTING

Storage key for limit setting configuration.

Stores the configured page size options available to users.

LIMIT

Storage key for current result limit/page size.

Stores how many products per page are currently displayed.

LOADING_FILTER_ICON_ID

METADATA_JSON

Pre-defined metadata JSON strings for common filter actions.

Contains stringified JSON metadata used in data-metadata attributes.

NEXT_PAGE

Storage key for tracking the next page URL/state.

Used for forward button functionality in pagination to load next page state.

PARALLAX_SPEED

Parallax scroll speed multiplier for visual effects.

Controls the speed of parallax scrolling animations.

PLACEMENT

Widget placement locations for analytics and behavior customization.

Defines where the filter widget is rendered on the site, affecting analytics tracking and behavior patterns.

PRE_ACTION

Storage key for previous user action.

Tracks the last filter action taken by the user for analytics and state management.

PRE_REQUEST_IDS

Storage key for previous request IDs to prevent duplicate requests.

Stores recent API request IDs to detect and cancel redundant calls.

PREV_PAGE

Storage key for tracking the previous page URL/state.

Used for back button functionality in pagination to restore previous page state.

PRODUCT_SWATCH_OPTION_TYPE

Swatch option type enum

QUERY_PARAM

Standard URL query parameter names for filter API requests.

Defines the parameter keys used when making requests to the Boost filter API. Technical Support teams can use these when building custom filter parameters.

REGEX_ESCAPE_PATTERN

Regular expression pattern for escaping special regex characters.

Used to safely escape user input before using it in regular expressions to prevent regex injection vulnerabilities.

RESOLUTION_BREAKPOINT

Responsive breakpoints for mobile and tablet detection.

Maximum pixel widths for device type classification.

RESPONSE_TYPE

API response format types.

Specifies whether the filter API should return JSON data or pre-rendered HTML.

RGB_COLOR_REGEX

SELECTED_PRODUCT_ID

Storage key for currently selected product ID.

Tracks which product is currently selected/focused.

SELECTED_PRODUCT_PAGE

Storage key for currently selected product page number.

Tracks which page of products is currently displayed.

SHOW_MORE_TYPES

Filter option "Show More" behavior types.

Defines how filter options are displayed when there are many values, controlling the expansion/collapse mechanism.

SWATCH_OPTION_TYPE

SWATCH_PREFIX

TEMPLATE_MAPPING

Template identifier mapping for filter widget components.

Maps template keys to their corresponding template IDs in the template system. Used by FilterHelper.getTemplate() to retrieve the correct HTML template.

TOOLBAR_CONTENT_SELECTOR

VIEW_MORE_CLICK_DEBOUNCE_TIME

XSS_REGEX

Abstract

AdditionalElementThemeSettings

AdditionalElement Settings

AppBlock

ApplicationLifecycleEvent

AssetFilesLoaderState

AsyncFactoryProvider

B2BRequestParams

BackInStockProductSettings

BackInStockVariant

BaseFilterValue

Base properties shared by all filter value types.

Contains the document count (number of products) matching this filter value.

BoostTAEConfig

BundleAction

BundleCartPayload

BundleDiscountType

BundleDisplayType

BundleTemplateName

CacheEntry

Cached API response with timestamp.

Used by FilterAPI to cache responses and avoid redundant network requests. Technical Support teams can extend FilterAPI to customize cache invalidation logic.

Callback

Event callback function signature.

CartButtonSettings

Cart Settings

CartDrawerWidgetDesignSettings

Design settings for cart-drawer recommendation widget. Configured in TAE Admin under recommendationWidgets['cart-drawer'][widgetId]

CartGeneralLayoutSettings

CartStyle

CartThemeSettings

ClassProvider

CollectionAndPageTabDescriptionSettings

CollectionAndPageTabTitleSettings

CollectionFilterValue

Collection filter value with extended metadata.

Used specifically for collection-type filters that include Shopify collection data like handles, tags, images, and HTML descriptions.

CollectionHeaderSettings

Color

CombinedListingsConfig

CombinedProductListingProduct

CombinedProductListingResponse

CombinedProductListingVariant

ConsequenceType

Consequence type for rule-based recommendations. Defines the "THEN" part of a rule - what products to show when conditions are met.

Constructor

CountdownCallAction

CTA action type

CountdownOnceEnd

Behavior when timer ends

CountdownPlacement

Placement scope

CountdownPositioning

Position of the countdown timer bar relative to the page viewport.

CountdownTimerType

Countdown display type

CurrencyInfo

CurrencyParams

DeepPartial

DOMActionHandler

DOMActionMap

EmailProvider

EventCallbackPair

Pair of event name and callback for bulk subscription operations.

EventHandler

Typed event handler that receives both custom data and base EventPayload.

EventName

Valid event name - either string literal or typed EVENT_NAMES key.

EventsMap

Map storing event subscriptions: event name -> array of callbacks.

Facet

FactoryProvider

FilterAPIAdditionParams

Additional options for customizing filter API requests.

Provides hooks for Technical Support teams to modify request parameters, control response format, and specify pagination behavior.

FilterAPIParams

URL parameters sent to the Boost filter API.

Key-value pairs representing filter selections, sorting, pagination, and other query parameters. Values can be arrays for multi-select filters or primitives for single-select options.

FilterAPIResponse

Response data from the Boost filter API.

Contains rendered HTML, updated filter options, dynamic bundles, and metadata including currency formatting and request tracking.

FilterBase

Base configuration properties shared by all filter types.

Contains display settings, behavior flags, and styling options that apply to every filter regardless of its value type (simple, collection, rating, tags).

FilterConfig

Complete filter configuration using discriminated union based on valueType.

This type ensures type safety when working with different filter value types. Use the valueType property to narrow the type and access the correctly-typed values array.

FilterFacets

FilterOptionsProps

Container for all filter options returned by the filter API.

This is the main data structure received from the Boost filter engine, containing all available filters and their current values.

FilterProps

Initial properties for filter widget initialization.

These properties are passed when creating a new filter widget instance, containing configuration, DOM context, and initial data.

FilterStates

Complete runtime state for an active filter widget.

Extends FilterProps with all runtime state management properties including loading states, user interactions, URL parameter mappings, and UI state.

FilterTreeBaseElementSettings

FilterTreeCheckbox

FilterTreeElements

FilterTreeFilterOption

FilterTreeFilterTitle

FilterTreeLine

FilterTreeProductCount

FilterTreeRefineBy

FilterTreeSearchBox

FilterTreeSettings

FilterTreeState

UI state to preserve during DOM updates

FontFamily

FontWeight

Guard

Type guard function for runtime type checking.

Used throughout the filter module to safely validate data structures from API responses or configuration.

HorizontalToolbarStickySyncTrigger

HTTPMethod

IBoostTAE

ISWBaseElementSettings

ISWDidYouMeanResultsSettings

ISWDidYouMeanSettings

ISWElements

ISWProductCompareAtPriceSettings

ISWProductPriceSettings

ISWProductSalePriceSettings

ISWProductSKUSettings

ISWProductTitleSettings

ISWProductVendorSettings

ISWResultsSettings

ISWSettings

ISWTitleMultipleElement

ISWViewAllButtonSettings

LazyModuleImport

A lazy module import is a function that returns a Promise resolving to a module class. This enables code-splitting and dynamic imports for modules.

LineSettings

ModuleImport

A module import can be either a static module class or a lazy import function

OffsetElementCollection

OffsetElementInput

PaginationButtonStyleSettings

PaginationNumberStyleSettings

PaginationSettings

PlaceholderSearchSettings

Position

Positions

PredictiveBundleControllerConnectProps

PredictiveBundleFocusRestoreKey

PredictiveBundleResolver

PreOrderExtendedAppConfig

PreOrderProductQueryParams

PriceRenderer

Function type for rendering price HTML

Primitive

Product

ProductBundle

ProductCountPaginationSettings

ProductImageGrid

ProductImageGridRow

ProductImgElement

ProductInfoElementSettings

ProductInfoInventoryStatusSettings

ProductInfoPriceSettings

ProductInfoTitleSettings

ProductInfoVendorSettings

ProductItemCTASettings

ProductItemGeneralSettings

ProductItemImageSettings

ProductItemInfoSettings

ProductItemLabelSettings

ProductItemsInfoElements

ProductItemThemeSettings

ProductListingCollection

ProductListingImageInfo

ProductListingMetafield

ProductListingOption

ProductListingOptionValue

ProductListingQueryParams

ProductListThemeSettings

ProductMetaField

ProductQueryParams

ProductSwatchItemSettings

Provider

QuickViewButtonOverallSettings

QuickViewButtonSettings

QuickView Settings

QuickViewThemeSettings

RangeFilterValue

Range filter value for price and other numeric range filters.

Used for filters that have minimum and maximum numeric bounds, such as price ranges or other continuous numeric values.

RatingFilterValue

Rating filter value for star rating filters.

Represents a rating range (e.g., "4 stars and up") with numeric bounds. Typically used with review integrations like Reviews.io.

RecommendationBundleClickOutsideOptions

RecommendationBundleDropdownOptions

RecommendationBundleEventOptions

RecommendationBundleRenderOptions

RecommendationExtendedAppConfig

RecommendationFilteringRuleBased

RecommendationFilteringRules

RecommendationPayload

RecommendationQueryParams

RecommendationResponse

RecommendationWidget

RecommendationWidgetControllerProps

Configuration properties for initializing the RecommendationWidgetController.

RecommendationWidgetControllerState

Internal state management for the recommendation widget controller.

RecommendationWidgetTrackingData

Tracking data structure for recommendation widgets.

Defines the shape of data stored for recommendation widget analytics and tracking. This data is persisted to localStorage to track user interactions with recommendation widgets and enable analytics reporting.

RootBindingRecord

ScopedSuggestionItemSettings

ScopedSuggestionLabelSettings

SearchBaseElementSettings

SearchElementWithBackground

SearchHeaderTextSettings

SearchPageElements

SearchPageSettings

SearchProductCountSettings

SelectorInput

SimpleFilterValue

Simple filter value for standard filters (color, size, vendor, tags, etc.).

Used for most filter types where each option has a key and display label.

Status

StickyLayoutType

StickyListener

StickyMode

StickyOverride

StickyStyleMap

SuggestionData

Combined suggestion data for rendering.

SupportedPage

SwatchOptionType

TagFilterValue

Tag filter value supporting hierarchical multi-level tag structures.

Used for nested tag filters where tags can have sub-tags (children). Includes action IDs and metadata for interactive expand/collapse behavior.

TagMetaActionOption

Metadata for tag filter option list actions.

Defines behavior when clicking on a tag filter option, including filter type, selection mode, and display format.

TagMetaData

Metadata containing action definitions for tag filter interactions.

Supports both option list actions and multi-level expand/collapse behavior.

Templates

TextTransform

ThemeSearchConfigMap

Map of theme names to their configurations.

ThemeSettings

TimerType

Timer type as stored in BE

TipForYouSettings

TitleTabSettings

Token

ToolbarElements

ToolbarFilterText

ToolbarProductCount

ToolbarRefineBy

ToolbarSettings

ToolBarShowLimitList

ToolbarSorting

ToolbarViewAs

Type

ViewMoreState

VolumeBundleAction

VolumeBundleDiscountType

VolumeBundleDisplayType

VolumeBundleEventCallback

VolumeBundleEventType

VolumeBundleTemplateName

Widget