@woodsportal/hubspot-kit 1.0.4 → 1.0.26

package/src/dev-module-config/__tests__/fixtures/golden-module.fixture.ts

@@ -0,0 +1,102 @@
+import type { ModuleFieldValues } from '../../schema/types'
+
+/** Minimal module values for transform golden tests (HubSpot-like portal theme). */
+export const goldenModuleFixture: ModuleFieldValues = {
+  add_home_tab: true,
+  backend_server_url: 'https://api.example.test',
+  home: {
+    tab_name: 'Dashboard',
+    icon_svg_code: '<svg></svg>',
+    view: 'cards',
+    enable_dashboard_cards: true,
+    dashboard_cards: [{ card_title: 'Open deals', card_type: 'count' }],
+    add_right_sidebar: false,
+    tabs_data_type: {},
+  },
+  menu_options: {
+    hubspot_defined_object: true,
+    hubspot_custom_object: false,
+    objects: [
+      {
+        tab_name: 'Contacts',
+        list_object_name: 'Contacts',
+        object_type_id: '0-1',
+        icon_svg_code: '<svg></svg>',
+        show_iframe: false,
+      },
+    ],
+    hubspot_custom_objects: [],
+  },
+  other_options: {
+    show_company_name: true,
+    show_sidebar_cta: false,
+    welcome_message: 'Welcome',
+    company_options: {
+      company_name: 'Acme Corp',
+      logo: { src: 'https://cdn.example/logo.png', alt: 'Logo' },
+      small_logo: { src: 'https://cdn.example/small.png', alt: 'Small' },
+      auth_popup_form_logo: { src: '', alt: '' },
+    },
+    sidebar_cta_details: {},
+    create_an_account_link: {
+      url: { href: 'https://example.test/signup', type: 'EXTERNAL' },
+    },
+    show_create_an_account_link: true,
+  },
+  style: {
+    module_global_colors: {
+      primary_color: { color: '#274E13', opacity: 100 },
+      secondary_color: { color: '#45818E', opacity: 100 },
+      button_text_color: { color: '#FFFFFF', opacity: 100 },
+    },
+    home_tab_styles: {
+      home_tab_banner_text_color: { color: '#111111', opacity: 100 },
+      description_color: { color: '#333333', opacity: 100 },
+      button_styles: {
+        background_color: { color: '#274E13', opacity: 100 },
+        text_color: { color: '#FFFFFF', opacity: 100 },
+      },
+      banner_overlayer_color: { color: '#274E13', opacity: 50 },
+      user_card_svg_color: { color: '#45818E', opacity: 100 },
+    },
+    sidebar_styles: {
+      text_color: { color: '#222222', opacity: 100 },
+      sidebar_background_color: { color: '#FFFFFF', opacity: 100 },
+    },
+    list_page_styles: {
+      heading_color: { color: '#111111', opacity: 100 },
+    },
+    details_page_styles: {
+      text_color: { color: '#111111', opacity: 100 },
+      banner_background_options: {
+        banner_color_1: { color: '#274E13', opacity: 100 },
+        banner_color_2: { color: '#45818E', opacity: 100 },
+      },
+    },
+    table_record_creation_button: {
+      background_color: { color: '#274E13', opacity: 100 },
+      text_color: { color: '#FFFFFF', opacity: 100 },
+    },
+    d_h_sidebar: {
+      background_color: { color: '#FFFFFF', opacity: 100 },
+      card_background_color: { color: '#F5F5F5', opacity: 100 },
+      text_color: { color: '#111111', opacity: 100 },
+    },
+    note_cards: {
+      hs_note_card_bg_color: { color: '#FFFFFF', opacity: 100 },
+      hs_note_ts_text_color: { color: '#666666', opacity: 100 },
+      wp_note_card_bg_color: { color: '#FFFFFF', opacity: 100 },
+      wp_note_ts_text_color: { color: '#666666', opacity: 100 },
+    },
+    sidebar_cta: {
+      background_color: { color: '#274E13', opacity: 100 },
+      text_color: { color: '#FFFFFF', opacity: 100 },
+      button_background_color: { color: '#45818E', opacity: 100 },
+      button_text_color: { color: '#FFFFFF', opacity: 100 },
+    },
+  },
+  developerMode: false,
+  developer_option: false,
+  developer_options: { temp_backend_url: '' },
+  sso_buttons_customize_options: {},
+}

package/src/dev-module-config/__tests__/module-config-storage.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest'
+import { exportConfigJson, importConfigJson } from '../storage/config-json'
+import { isFieldVisible } from '../schema/visibility'
+import { validateModuleConfig } from '../schema/validate-module-config'
+import type { HubSpotFieldDefinition, ModuleFieldValues } from '../schema/types'
+
+describe('config-json', () => {
+  it('round-trips module values', () => {
+    const moduleValues: ModuleFieldValues = { style: { primary_color: { color: '#112233', opacity: 100 } } }
+    const raw = exportConfigJson(moduleValues)
+    expect(importConfigJson(raw)).toEqual(moduleValues)
+  })
+})
+
+describe('visibility hubspot_data_source default', () => {
+  it('hides fields gated on hubspot_data_source when control is absent', () => {
+    const field: HubSpotFieldDefinition = {
+      name: 'list_object_properties',
+      label: 'List object properties',
+      type: 'text',
+      visibility: {
+        controlling_field_path: 'hubspot_data_source',
+        controlling_value_regex: 'true',
+        operator: 'EQUAL',
+      },
+    }
+
+    expect(isFieldVisible(field, { moduleValues: {} })).toBe(false)
+  })
+})
+
+describe('validateModuleConfig', () => {
+  it('reports missing required fields', () => {
+    const schema: Array<HubSpotFieldDefinition> = [
+      { name: 'welcome_message', label: 'Welcome Message', type: 'text', required: true },
+    ]
+    const errors = validateModuleConfig(schema, { welcome_message: '' })
+    expect(errors.some((error) => error.path === 'welcome_message')).toBe(true)
+  })
+})

package/src/dev-module-config/__tests__/module-config-transform.test.ts

@@ -0,0 +1,55 @@
+import fieldsSchema from './fixtures/fields.json'
+import { buildDefaultsFromFields } from '../schema/extract-defaults'
+import { buildCssVarsFromFields, buildHubSpotDataFromFields } from '../transform/build-hubspot-data'
+import { normalizeFieldChoices } from '../schema/normalize-choices'
+import { goldenModuleFixture } from './fixtures/golden-module.fixture'
+
+
+describe('normalizeFieldChoices', () => {
+  it('parses HubSpot tuple choices', () => {
+    const choices = normalizeFieldChoices({
+      name: 'object_type_id',
+      label: 'Object Type',
+      type: 'choice',
+      choices: [['0-5', 'Tickets (0-5)'], ['0-3', 'Deals (0-3)']],
+    })
+    expect(choices).toEqual([
+      { value: '0-5', label: 'Tickets (0-5)' },
+      { value: '0-3', label: 'Deals (0-3)' },
+    ])
+  })
+})
+
+describe('buildDefaultsFromFields', () => {
+  it('extracts primary and secondary color defaults from fields.json', () => {
+    const defaults = buildDefaultsFromFields(fieldsSchema as never)
+    const style = defaults.style as Record<string, unknown>
+    const globals = style.module_global_colors as Record<string, { color: string }>
+
+    expect(globals.primary_color.color).toBe('#FF7A59')
+    expect(globals.secondary_color.color).toBe('#2797AF')
+  })
+})
+
+describe('buildHubSpotDataFromFields', () => {
+  it('maps module style colors to hubSpotData primary/secondary fields', () => {
+    const built = buildHubSpotDataFromFields(goldenModuleFixture)
+
+    expect(built.primarycolor).toBe('#274E13')
+    expect(built.secondarycolor).toBe('#45818E')
+    expect(built.addHomeTabOption).toBe(true)
+    expect(built.enableDashboardCards).toBe(true)
+    expect(built.sidebarMenuOptions.length).toBeGreaterThan(0)
+  })
+})
+
+describe('buildCssVarsFromFields', () => {
+  it('sets :root primary and secondary CSS variables from module styles', () => {
+    const vars = buildCssVarsFromFields(goldenModuleFixture)
+
+    expect(vars['--primary-color']).toBe('#274E13')
+    expect(vars['--secondary-color']).toBe('#45818E')
+    expect(vars['--primary-color-hover-bg']).toBe('#274E1330')
+    expect(vars['--secondary-color-hover-bg']).toBe('#45818E10')
+  })
+})

package/src/dev-module-config/__tests__/normalize-repeater-items.test.ts

@@ -0,0 +1,46 @@
+import { normalizeRepeaterItems } from '../schema/normalize-repeater-items'
+import { buildHubSpotDataFromFields } from '../transform/build-hubspot-data'
+import { goldenModuleFixture } from './fixtures/golden-module.fixture'
+
+describe('normalizeRepeaterItems', () => {
+  it('returns arrays unchanged', () => {
+    const items = [{ list_object_name: 'Tickets' }, { list_object_name: 'Deals' }]
+    expect(normalizeRepeaterItems(items)).toEqual(items)
+  })
+
+  it('wraps a single object row', () => {
+    const row = { list_object_name: 'Tickets', object_type_id: '0-5' }
+    expect(normalizeRepeaterItems(row)).toEqual([row])
+  })
+
+  it('converts numeric-key objects to arrays', () => {
+    expect(
+      normalizeRepeaterItems({
+        0: { list_object_name: 'Tickets' },
+        1: { list_object_name: 'Deals' },
+      }),
+    ).toEqual([{ list_object_name: 'Tickets' }, { list_object_name: 'Deals' }])
+  })
+})
+
+describe('buildHubSpotDataFromFields right sidebar', () => {
+  it('maps enabled right sidebar objects from a single-object repeater value', () => {
+    const built = buildHubSpotDataFromFields({
+      ...goldenModuleFixture,
+      home: {
+        ...(goldenModuleFixture.home as Record<string, unknown>),
+        add_right_sidebar: true,
+        right_sidebar_object: {
+          list_object_name: 'Tickets',
+          object_type_id: '0-5',
+          show_iframe: false,
+        },
+      },
+    })
+
+    expect(built.showSidebarListDataOption).toBe(true)
+    expect(built.sidebarListDataOption).toHaveLength(1)
+    expect(built.sidebarListDataOption[0]?.label).toBe('Tickets')
+    expect(built.sidebarListDataOption[0]?.hubspotObjectTypeId).toBe('0-5')
+  })
+})

package/src/dev-module-config/dev-module-display-name.ts

@@ -0,0 +1,5 @@
+/** Module slug from woodscli.json — injected by Vite in local dev. */
+export function devModuleDisplayName(): string {
+  const name = import.meta.env.VITE_WPHS_MODULE_NAME
+  return typeof name === 'string' && name.trim() ? name.trim() : 'module'
+}

package/src/dev-module-config/runtime/module-config-bridge.ts

@@ -0,0 +1,27 @@
+import { MODULE_CONFIG_CHANGED } from '../schema/types'
+import type { ModuleConfigState } from './module-config-runtime'
+import type { HubSpotKitAdapter } from '../../adapters/types.js'
+
+let adapterRef: HubSpotKitAdapter | null = null
+
+export function setModuleConfigAdapter(adapter: HubSpotKitAdapter): void {
+  adapterRef = adapter
+}
+
+function getAdapter(): HubSpotKitAdapter {
+  if (!adapterRef) {
+    throw new Error('Module config adapter not set. Import wphs.adapter.ts in bootstrap.')
+  }
+  return adapterRef
+}
+
+export function bindModuleConfigToHubSpotData(): void {
+  window.addEventListener(MODULE_CONFIG_CHANGED, (event) => {
+    const detail = (event as CustomEvent<ModuleConfigState>).detail
+    getAdapter().syncLiveData(detail.built)
+  })
+}
+
+export function syncHubSpotDataFromModuleState(state: ModuleConfigState): void {
+  getAdapter().syncLiveData(state.built)
+}

package/src/dev-module-config/runtime/module-config-runtime.ts

@@ -0,0 +1,185 @@
+import { loadModuleDefaults } from '../schema/extract-defaults'
+import { deepMerge } from '../schema/deep-merge'
+import { MODULE_CONFIG_CHANGED } from '../schema/types'
+import {
+  clearOverrides,
+  exportConfigJson,
+  importConfigJson,
+  loadOverrides,
+  saveOverrides,
+} from '../storage/workspace-store'
+import { buildApiRoutes } from '@woodsportal/hubspot-kit/routing/build-api-routes'
+import {
+  applyCreateButtonStyles,
+  applyCssVarsToDocument,
+  buildCssVarsFromFields,
+  buildHubSpotDataFromFields,
+} from '../transform/build-hubspot-data'
+import type { BuiltHubSpotData } from '../transform/build-hubspot-data'
+import type { HubSpotFieldDefinition, ModuleFieldValues } from '../schema/types'
+import type { HubSpotPortalData } from '@/hubspot/types'
+import { defaultData } from '@/defaultData'
+
+export type ModuleConfigState = {
+  schema: Array<HubSpotFieldDefinition>
+  defaults: ModuleFieldValues
+  overrides: ModuleFieldValues
+  moduleValues: ModuleFieldValues
+  built: BuiltHubSpotData
+  apiRoutes: ReturnType<typeof buildApiRoutes>
+}
+
+let state: ModuleConfigState | null = null
+let schemaCache: Array<HubSpotFieldDefinition> | null = null
+
+async function loadSchema(): Promise<Array<HubSpotFieldDefinition>> {
+  if (schemaCache) return schemaCache
+  const response = await fetch('/fields.json')
+  if (!response.ok) throw new Error('Failed to load fields.json')
+  schemaCache = (await response.json()) as Array<HubSpotFieldDefinition>
+  return schemaCache
+}
+
+function buildState(
+  schema: Array<HubSpotFieldDefinition>,
+  defaults: ModuleFieldValues,
+  overrides: ModuleFieldValues,
+): ModuleConfigState {
+  const moduleValues = deepMerge(defaults, overrides)
+  const built = buildHubSpotDataFromFields(moduleValues)
+  const apiRoutes = buildApiRoutes(built.sidebarMenuOptions)
+  return { schema, defaults, overrides, moduleValues, built, apiRoutes }
+}
+
+function applyRuntimeSideEffects(state: ModuleConfigState): void {
+  applyCssVarsToDocument(buildCssVarsFromFields(state.moduleValues))
+  applyCreateButtonStyles(state.moduleValues)
+}
+
+export async function initModuleConfigRuntime(): Promise<ModuleConfigState> {
+  const [schema, defaults, overrides] = await Promise.all([
+    loadSchema(),
+    loadModuleDefaults(),
+    loadOverrides(),
+  ])
+  state = buildState(schema, defaults, overrides)
+  applyRuntimeSideEffects(state)
+  return state
+}
+
+export function getModuleConfigState(): ModuleConfigState | null {
+  return state
+}
+
+export function getBuiltHubSpotData(): BuiltHubSpotData | null {
+  return state?.built ?? null
+}
+
+export function getModuleFieldValues(): ModuleFieldValues {
+  return state?.moduleValues ?? {}
+}
+
+export function getModuleApiRoutes() {
+  return state?.apiRoutes ?? []
+}
+
+export async function updateModuleFieldValues(
+  nextModuleValues: ModuleFieldValues,
+): Promise<ModuleConfigState> {
+  if (!state) throw new Error('Module config runtime not initialized')
+  const overrides = deepMerge({}, nextModuleValues)
+  state = buildState(state.schema, state.defaults, overrides)
+  await saveOverrides(overrides)
+  applyRuntimeSideEffects(state)
+  window.dispatchEvent(new CustomEvent(MODULE_CONFIG_CHANGED, { detail: state }))
+  return state
+}
+
+export async function resetModuleConfigToDefaults(): Promise<ModuleConfigState> {
+  if (!state) throw new Error('Module config runtime not initialized')
+  await clearOverrides()
+  state = buildState(state.schema, state.defaults, {})
+  applyRuntimeSideEffects(state)
+  window.dispatchEvent(new CustomEvent(MODULE_CONFIG_CHANGED, { detail: state }))
+  return state
+}
+
+export async function exportModuleConfig(): Promise<string> {
+  const moduleValues = getModuleFieldValues()
+  return exportConfigJson(moduleValues)
+}
+
+export async function importModuleConfig(raw: string): Promise<ModuleConfigState> {
+  const moduleValues = importConfigJson(raw)
+  return updateModuleFieldValues(moduleValues)
+}
+
+/** Merge CMS module config with local-only auth fixtures from defaultData. */
+export function buildFullDevHubSpotPortalData(): HubSpotPortalData {
+  const built = getBuiltHubSpotData()
+  if (!built) {
+    return {
+      dataSourceSet: defaultData.dataSourceSet,
+      hubId: defaultData.hubId,
+      userData: defaultData.userData,
+      objectList: defaultData.objectList,
+    }
+  }
+
+  return {
+    dataSourceSet: built.dataSourceSet,
+    hubId: defaultData.hubId,
+    apiBaseUrlOption: built.apiBaseUrlOption,
+    userData: defaultData.userData,
+    objectList: defaultData.objectList,
+    showCompanyNameOption: built.showCompanyNameOption,
+    showSidebarCtaOption: built.showSidebarCtaOption,
+    addHomeTabOption: built.addHomeTabOption,
+    sidebarMenuOptions: built.sidebarMenuOptions,
+    moduleIframeListOptions: built.moduleIframeListOptions,
+    sidebarListDataOption: built.sidebarListDataOption,
+    showSidebarListDataOption: built.showSidebarListDataOption,
+    sidebarCtaDetails: built.sidebarCtaDetails,
+    baseCompanyOptions: built.baseCompanyOptions,
+    enableDashboardCards: built.enableDashboardCards,
+    dashboardCards: built.dashboardCards,
+    homeTabsDataTypeFilter: built.homeTabsDataTypeFilter,
+    moduleStylesOptions: built.moduleStylesOptions,
+    recorBtnCustom: built.recorBtnCustom,
+    sidebarCtaStyles: built.sidebarCtaStyles,
+    developerModeModule: built.developerModeModule,
+    developerOptionTempUrl: built.developerOptionTempUrl,
+    developerOption: built.developerOption,
+    ssoButtonsCustomizeOptions: built.ssoButtonsCustomizeOptions,
+    isInEditor: false,
+  }
+}
+
+export function setNestedValue(
+  obj: ModuleFieldValues,
+  path: string,
+  value: unknown,
+): ModuleFieldValues {
+  const parts = path.split('.')
+  const result = structuredClone(obj)
+  let cursor: Record<string, unknown> = result
+
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i]
+    const next = cursor[key]
+    if (next === null || typeof next !== 'object' || Array.isArray(next)) {
+      cursor[key] = {}
+    }
+    cursor = cursor[key] as Record<string, unknown>
+  }
+
+  cursor[parts[parts.length - 1]] = value
+  return result
+}
+
+export function getNestedValue(obj: ModuleFieldValues, path: string): unknown {
+  return path.split('.').reduce<unknown>((acc, key) => {
+    if (acc === null || acc === undefined || typeof acc !== 'object') return undefined
+    return (acc as Record<string, unknown>)[key]
+  }, obj)
+}

package/src/dev-module-config/schema/build-default-item.ts

@@ -0,0 +1,7 @@
+import { buildDefaultsFromFields } from './extract-defaults'
+import type { HubSpotFieldDefinition, ModuleFieldValues } from './types'
+
+/** Build a single repeater row default from field children (uses fields.json defaults). */
+export function buildDefaultItemFromChildren(children: Array<HubSpotFieldDefinition>): ModuleFieldValues {
+  return buildDefaultsFromFields(children)
+}

package/src/dev-module-config/schema/deep-merge.ts

@@ -0,0 +1,27 @@
+export function deepMerge<T extends Record<string, unknown>>(
+  base: T,
+  patch: Record<string, unknown>,
+): T {
+  const result = { ...base } as Record<string, unknown>
+
+  for (const [key, patchValue] of Object.entries(patch)) {
+    const baseValue = result[key]
+    if (
+      patchValue !== null &&
+      typeof patchValue === 'object' &&
+      !Array.isArray(patchValue) &&
+      baseValue !== null &&
+      typeof baseValue === 'object' &&
+      !Array.isArray(baseValue)
+    ) {
+      result[key] = deepMerge(
+        baseValue as Record<string, unknown>,
+        patchValue as Record<string, unknown>,
+      )
+    } else {
+      result[key] = patchValue
+    }
+  }
+
+  return result as T
+}

package/src/dev-module-config/schema/extract-defaults.ts

@@ -0,0 +1,62 @@
+import type { HubSpotFieldDefinition, ModuleFieldValues } from './types'
+
+function isFieldGroup(field: HubSpotFieldDefinition): boolean {
+  return field.type === 'group' && Array.isArray(field.children)
+}
+
+function defaultOccurrenceCount(field: HubSpotFieldDefinition): number {
+  const occurrence = field.occurrence
+  if (!occurrence) return 0
+  const raw = occurrence.default ?? occurrence.min ?? 0
+  const count = Number(raw)
+  return Number.isFinite(count) && count > 0 ? count : 0
+}
+
+function defaultForField(field: HubSpotFieldDefinition): unknown {
+  if (field.default !== undefined) return structuredClone(field.default)
+  if (isFieldGroup(field)) {
+    const row = buildDefaultsFromFields(field.children ?? [])
+    if (field.occurrence) {
+      const count = defaultOccurrenceCount(field)
+      return Array.from({ length: count }, () => structuredClone(row))
+    }
+    return row
+  }
+  if (field.type === 'boolean') return false
+  if (field.type === 'number') return 0
+  if (field.type === 'color') return { color: '', opacity: 100 }
+  if (field.type === 'image') return { src: '', alt: '' }
+  if (field.type === 'url' || field.type === 'link') {
+    return {
+      url: { href: '', type: 'EXTERNAL' },
+      open_in_new_tab: false,
+      no_follow: false,
+    }
+  }
+  return ''
+}
+
+export function buildDefaultsFromFields(
+  fields: Array<HubSpotFieldDefinition>,
+): ModuleFieldValues {
+  const result: ModuleFieldValues = {}
+
+  for (const field of fields) {
+    result[field.name] = defaultForField(field)
+  }
+
+  return result
+}
+
+export async function loadFieldsSchema(): Promise<Array<HubSpotFieldDefinition>> {
+  const response = await fetch('/fields.json')
+  if (!response.ok) {
+    throw new Error(`Failed to load fields.json: ${response.status}`)
+  }
+  return (await response.json()) as Array<HubSpotFieldDefinition>
+}
+
+export async function loadModuleDefaults(): Promise<ModuleFieldValues> {
+  const schema = await loadFieldsSchema()
+  return buildDefaultsFromFields(schema)
+}

package/src/dev-module-config/schema/normalize-choices.ts

@@ -0,0 +1,18 @@
+import type { HubSpotFieldDefinition } from './types'
+
+export type NormalizedChoice = { value: string; label: string }
+
+export function normalizeFieldChoices(field: HubSpotFieldDefinition): Array<NormalizedChoice> {
+  const raw = field.choices ?? []
+  return raw.map((entry) => {
+    if (Array.isArray(entry)) {
+      const [value, label] = entry
+      return { value: String(value), label: String(label ?? value) }
+    }
+    if (entry && typeof entry === 'object' && 'value' in entry) {
+      const choice = entry as { value: string; label?: string }
+      return { value: String(choice.value), label: String(choice.label ?? choice.value) }
+    }
+    return { value: String(entry), label: String(entry) }
+  })
+}

package/src/dev-module-config/schema/normalize-repeater-items.ts

@@ -0,0 +1,31 @@
+import type { ModuleFieldValues } from './types'
+
+/** HubSpot repeaters are arrays; legacy defaults or partial merges may store a single object. */
+export function normalizeRepeaterItems(value: unknown): Array<ModuleFieldValues> {
+  if (Array.isArray(value)) {
+    return value.filter(
+      (item): item is ModuleFieldValues =>
+        item !== null && typeof item === 'object' && !Array.isArray(item),
+    )
+  }
+
+  if (value && typeof value === 'object') {
+    const record = value as Record<string, unknown>
+    const keys = Object.keys(record)
+    if (keys.length > 0 && keys.every((key) => /^\d+$/.test(key))) {
+      return keys
+        .sort((a, b) => Number(a) - Number(b))
+        .map((key) => record[key])
+        .filter(
+          (item): item is ModuleFieldValues =>
+            item !== null && typeof item === 'object' && !Array.isArray(item),
+        )
+    }
+
+    if (keys.length > 0) {
+      return [record as ModuleFieldValues]
+    }
+  }
+
+  return []
+}

package/src/dev-module-config/schema/parse-fields-json.ts

@@ -0,0 +1,2 @@
+export { loadFieldsSchema, buildDefaultsFromFields, loadModuleDefaults } from './extract-defaults'
+export type { HubSpotFieldDefinition, ModuleFieldValues, HubSpotFieldTab } from './types'