@census-ai/census-sdk 0.2.0 → 0.4.1

package/dist/react/index.d.ts

@@ -1,4 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode } from 'react';
 
 /**
  * Configuration options for the Census SDK
@@ -105,7 +107,7 @@ interface Article {
     read_time_minutes: number | null;
     published_at: string | null;
     sort_order: number;
-    content?: unknown;
+    content?: string;
     content_html?: string;
     features?: {
         id: string;
@@ -113,6 +115,36 @@ interface Article {
         slug: string;
     };
 }
+/**
+ * A feature within a feature group
+ */
+interface Feature {
+    id: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    status: string;
+    article_count: number;
+}
+/**
+ * A feature group containing features
+ */
+interface FeatureGroup {
+    id: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    color: string | null;
+    features: Feature[];
+    feature_count: number;
+    article_count: number;
+}
+/**
+ * Response from feature groups endpoint
+ */
+interface FeatureGroupsResponse {
+    feature_groups: FeatureGroup[];
+}
 /**
  * Options for fetching articles
  */
@@ -224,6 +256,272 @@ interface RequestsResponse {
         hasMore: boolean;
     };
 }
+/**
+ * Step types for guides
+ */
+type GuideStepType = 'tooltip' | 'modal' | 'slideout' | 'hotspot' | 'banner';
+/**
+ * Tooltip position options
+ */
+type TooltipPosition = 'auto' | 'top' | 'bottom' | 'left' | 'right';
+/**
+ * Step advancement trigger types
+ */
+type AdvanceTrigger = 'button' | 'click' | 'delay' | 'form-submit';
+/**
+ * Form types for guide steps
+ */
+type GuideFormType = 'nps' | 'rating' | 'text' | 'select' | 'multi-select';
+/**
+ * Rich content for guide steps
+ */
+interface GuideStepRichContent {
+    title?: string;
+    body?: string;
+    media?: {
+        type: 'image' | 'video';
+        url: string;
+        alt?: string;
+    };
+    buttons?: Array<{
+        label: string;
+        action: 'next' | 'prev' | 'dismiss' | 'url' | 'custom';
+        url?: string;
+        customAction?: string;
+        style?: 'primary' | 'secondary' | 'text';
+    }>;
+    form?: {
+        type: GuideFormType;
+        question: string;
+        options?: string[];
+        required?: boolean;
+        submitLabel?: string;
+    };
+}
+/**
+ * Display configuration for guide steps
+ */
+interface GuideStepDisplayConfig {
+    position?: TooltipPosition | 'center';
+    offset?: {
+        x: number;
+        y: number;
+    };
+    width?: number;
+    backdrop?: boolean;
+    spotlightPadding?: number;
+    bannerPosition?: 'top' | 'bottom';
+}
+/**
+ * Advancement configuration for guide steps
+ */
+interface GuideStepAdvanceConfig {
+    trigger: AdvanceTrigger;
+    delay?: number;
+    clickSelector?: string;
+}
+/**
+ * Style configuration for guide steps
+ */
+interface GuideStepStyleConfig {
+    backgroundColor?: string;
+    textColor?: string;
+    accentColor?: string;
+    borderRadius?: number;
+    customCSS?: string;
+}
+/**
+ * Selector strategy for targeting elements
+ */
+interface SelectorStrategy {
+    css?: string;
+    xpath?: string;
+    text?: string;
+    testId?: string;
+}
+/**
+ * Guide step definition
+ */
+interface GuideStep {
+    id: string;
+    guide_id?: string;
+    sort_order: number;
+    step_type: GuideStepType;
+    selector_strategy: SelectorStrategy | null;
+    title: string | null;
+    content: string | null;
+    tooltip_position: TooltipPosition;
+    actions: Array<Record<string, unknown>>;
+    wait_for: 'click' | 'next_button' | 'delay' | 'custom';
+    wait_config: Record<string, unknown>;
+    rich_content: GuideStepRichContent;
+    display_config: GuideStepDisplayConfig;
+    advance_config: GuideStepAdvanceConfig;
+    style_config: GuideStepStyleConfig;
+    created_at?: string;
+    updated_at?: string;
+}
+/**
+ * Guide trigger types
+ */
+type GuideTriggerType = 'manual' | 'url_match' | 'first_visit' | 'event';
+/**
+ * Guide status
+ */
+type GuideStatus = 'draft' | 'published' | 'archived';
+/**
+ * Guide definition
+ */
+interface Guide {
+    id: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    trigger_type: GuideTriggerType;
+    trigger_config: Record<string, unknown>;
+    theme: Record<string, unknown>;
+    allow_skip: boolean;
+    show_progress: boolean;
+    status?: GuideStatus;
+    published_at?: string | null;
+    created_at?: string;
+    updated_at?: string;
+    guide_steps: GuideStep[];
+}
+/**
+ * Options for creating a guide
+ */
+interface CreateGuideOptions {
+    /**
+     * Name of the guide
+     */
+    name: string;
+    /**
+     * URL-friendly slug (lowercase, hyphens only)
+     */
+    slug: string;
+    /**
+     * Description of the guide
+     */
+    description?: string;
+    /**
+     * Project ID to associate with
+     */
+    projectId?: string;
+    /**
+     * When to trigger the guide
+     * @default "manual"
+     */
+    triggerType?: GuideTriggerType;
+    /**
+     * Configuration for the trigger (e.g., url_pattern for url_match)
+     */
+    triggerConfig?: Record<string, unknown>;
+    /**
+     * Theme customization
+     */
+    theme?: Record<string, unknown>;
+    /**
+     * Allow users to skip the guide
+     * @default true
+     */
+    allowSkip?: boolean;
+    /**
+     * Show progress indicator
+     * @default true
+     */
+    showProgress?: boolean;
+}
+/**
+ * Options for updating a guide
+ */
+interface UpdateGuideOptions {
+    name?: string;
+    slug?: string;
+    description?: string;
+    triggerType?: GuideTriggerType;
+    triggerConfig?: Record<string, unknown>;
+    theme?: Record<string, unknown>;
+    allowSkip?: boolean;
+    showProgress?: boolean;
+    status?: GuideStatus;
+}
+/**
+ * Options for creating a guide step
+ */
+interface CreateGuideStepOptions {
+    /**
+     * Type of step
+     * @default "tooltip"
+     */
+    stepType?: GuideStepType;
+    /**
+     * Order position (auto-assigned if not provided)
+     */
+    sortOrder?: number;
+    /**
+     * Element selector strategy
+     */
+    selectorStrategy?: SelectorStrategy;
+    /**
+     * Simple title (legacy, use richContent.title instead)
+     */
+    title?: string;
+    /**
+     * Simple content (legacy, use richContent.body instead)
+     */
+    content?: string;
+    /**
+     * Tooltip position
+     * @default "auto"
+     */
+    tooltipPosition?: TooltipPosition;
+    /**
+     * Rich content configuration
+     */
+    richContent?: GuideStepRichContent;
+    /**
+     * Display configuration
+     */
+    displayConfig?: GuideStepDisplayConfig;
+    /**
+     * Advancement configuration
+     */
+    advanceConfig?: GuideStepAdvanceConfig;
+    /**
+     * Style overrides
+     */
+    styleConfig?: GuideStepStyleConfig;
+}
+/**
+ * Options for updating a guide step
+ */
+interface UpdateGuideStepOptions extends Partial<CreateGuideStepOptions> {
+}
+/**
+ * Options for fetching guides
+ */
+interface GuidesOptions {
+    /**
+     * Filter by project ID
+     */
+    projectId?: string;
+    /**
+     * Current page URL (for trigger matching)
+     */
+    url?: string;
+    /**
+     * User ID (to get completion status)
+     */
+    userId?: string;
+}
+/**
+ * Response from guides list endpoint
+ */
+interface GuidesResponse {
+    guides: Guide[];
+    completedGuides: string[];
+}
 /**
  * Position for floating UI elements
  */
@@ -360,6 +658,70 @@ interface RequestsProps {
      */
     onRequestClick?: (request: Request) => void;
 }
+/**
+ * Available tabs in the HelpCenter component
+ */
+type HelpCenterTab = 'articles' | 'requests';
+/**
+ * Props for the HelpCenter component
+ */
+interface HelpCenterProps {
+    /**
+     * Which tabs to show. Order determines tab order.
+     * @default ['articles', 'requests']
+     *
+     * @example
+     * // Show both tabs
+     * tabs={['articles', 'requests']}
+     *
+     * // Articles only (e.g., documentation page)
+     * tabs={['articles']}
+     *
+     * // Requests only (e.g., feedback page)
+     * tabs={['requests']}
+     */
+    tabs?: HelpCenterTab[];
+    /**
+     * Default tab to show on load
+     * @default First tab in the tabs array
+     */
+    defaultTab?: HelpCenterTab;
+    /**
+     * Custom labels for tabs
+     * @default { articles: 'Articles', requests: 'My Requests' }
+     */
+    tabLabels?: Partial<Record<HelpCenterTab, string>>;
+    /**
+     * Show search bar in articles tab
+     * @default true
+     */
+    showSearch?: boolean;
+    /**
+     * Show category filters in articles tab
+     * @default true
+     */
+    showCategories?: boolean;
+    /**
+     * Theme customization
+     */
+    theme?: CensusTheme;
+    /**
+     * Custom CSS class
+     */
+    className?: string;
+    /**
+     * Callback when an article is viewed
+     */
+    onArticleView?: (article: Article) => void;
+    /**
+     * Callback when a request is clicked
+     */
+    onRequestClick?: (request: Request) => void;
+    /**
+     * Callback when the active tab changes
+     */
+    onTabChange?: (tab: HelpCenterTab) => void;
+}
 /**
  * Props for the CensusProvider component
  */
@@ -389,58 +751,6 @@ interface CensusProviderProps {
      */
     children: React.ReactNode;
 }
-interface GuideStep {
-    id: string;
-    sort_order: number;
-    selector_strategy: SelectorStrategy;
-    title: string | null;
-    content: string | null;
-    tooltip_position: TooltipPosition;
-    actions: GuideAction[];
-    wait_for: WaitForType;
-    wait_config: Record<string, unknown>;
-}
-interface SelectorStrategy {
-    css?: string;
-    xpath?: string;
-    text?: string;
-    testId?: string;
-}
-type TooltipPosition = 'auto' | 'top' | 'bottom' | 'left' | 'right';
-type WaitForType = 'click' | 'next_button' | 'delay' | 'custom';
-interface GuideAction {
-    type: 'click' | 'input' | 'navigate' | 'custom';
-    config: Record<string, unknown>;
-}
-interface Guide {
-    id: string;
-    name: string;
-    slug: string;
-    description: string | null;
-    trigger_type: GuideTriggerType;
-    trigger_config: TriggerConfig;
-    theme: GuideTheme;
-    allow_skip: boolean;
-    show_progress: boolean;
-    guide_steps: GuideStep[];
-}
-type GuideTriggerType = 'manual' | 'url_match' | 'first_visit' | 'event';
-interface TriggerConfig {
-    url_pattern?: string;
-    event_name?: string;
-    delay_ms?: number;
-}
-interface GuideTheme {
-    primaryColor?: string;
-    backgroundColor?: string;
-    textColor?: string;
-    borderRadius?: string;
-    fontFamily?: string;
-}
-interface GuidesResponse {
-    guides: Guide[];
-    completedGuides: string[];
-}
 type GuideEventType = 'started' | 'step_viewed' | 'step_completed' | 'completed' | 'skipped' | 'dismissed';
 interface GuideAnalyticsEvent {
     guideId: string;
@@ -563,6 +873,21 @@ declare class CensusClient {
      * ```
      */
     getArticle(slugOrId: string): Promise<Article | null>;
+    /**
+     * Fetch feature groups with their features.
+     * Used by the HelpCenter component for navigation.
+     *
+     * @returns Feature groups with features and article counts
+     *
+     * @example
+     * ```typescript
+     * const { feature_groups } = await census.getFeatureGroups();
+     * feature_groups.forEach(group => {
+     *   console.log(group.name, group.features.length);
+     * });
+     * ```
+     */
+    getFeatureGroups(): Promise<FeatureGroupsResponse>;
     /**
      * Fetch the current user's submitted requests (feedback, bugs, feature requests).
      * Requires a user to be identified first.
@@ -617,60 +942,193 @@ declare class CensusClient {
      */
     trackBatch(options: BatchEventsOptions): Promise<void>;
     /**
-     * Fetch available guides for the current user.
-     * Returns guides that match the user's context and haven't been completed.
+     * Get published guides.
      *
-     * @returns Guides and list of completed guide IDs
+     * @param options - Query options
+     * @returns Guides and completion status
      *
      * @example
      * ```typescript
-     * const { guides, completedGuides } = await census.getGuides();
-     * guides.forEach(guide => console.log(guide.name));
+     * const { guides, completedGuides } = await census.getGuides({
+     *   url: window.location.href,
+     *   userId: 'user_123',
+     * });
      * ```
      */
-    getGuides(): Promise<GuidesResponse>;
+    getGuides(options?: GuidesOptions): Promise<GuidesResponse>;
     /**
-     * Fetch a single guide by slug or ID.
+     * Get a single guide by ID.
      *
-     * @param slugOrId - Guide slug or ID
-     * @returns Guide or null if not found
+     * @param guideId - Guide ID
+     * @returns Guide with steps or null if not found
      *
      * @example
      * ```typescript
-     * const guide = await census.getGuide('onboarding-tour');
+     * const guide = await census.getGuide('guide_123');
      * if (guide) {
      *   console.log(guide.name, guide.guide_steps.length);
      * }
      * ```
      */
-    getGuide(slugOrId: string): Promise<Guide | null>;
+    getGuide(guideId: string): Promise<Guide | null>;
     /**
-     * Track a guide analytics event.
-     * Used to track user progress through guides.
+     * Create a new guide.
+     * Requires guides:create or guides:admin scope.
      *
-     * @param event - Guide analytics event
+     * @param options - Guide creation options
+     * @returns Created guide
      *
      * @example
      * ```typescript
-     * await census.trackGuideEvent({
-     *   guideId: 'guide_123',
-     *   eventType: 'step_completed',
-     *   stepId: 'step_456',
-     *   stepIndex: 2,
-     *   sessionId: 'session_789',
+     * const guide = await census.createGuide({
+     *   name: 'Welcome Tour',
+     *   slug: 'welcome-tour',
+     *   description: 'Introduction to the app',
+     *   triggerType: 'first_visit',
      * });
      * ```
      */
-    trackGuideEvent(event: GuideAnalyticsEvent): Promise<void>;
+    createGuide(options: CreateGuideOptions): Promise<Guide>;
     /**
-     * Mark a guide as completed for the current user.
-     * Prevents the guide from showing again.
+     * Update an existing guide.
+     * Requires guides:create or guides:admin scope.
      *
-     * @param guideId - ID of the guide to mark as completed
+     * @param guideId - Guide ID to update
+     * @param options - Update options
+     * @returns Updated guide
      *
      * @example
      * ```typescript
-     * await census.markGuideCompleted('guide_123');
+     * const guide = await census.updateGuide('guide_123', {
+     *   name: 'Updated Tour Name',
+     *   status: 'published',
+     * });
+     * ```
+     */
+    updateGuide(guideId: string, options: UpdateGuideOptions): Promise<Guide>;
+    /**
+     * Delete a guide.
+     * Requires guides:admin scope.
+     *
+     * @param guideId - Guide ID to delete
+     *
+     * @example
+     * ```typescript
+     * await census.deleteGuide('guide_123');
+     * ```
+     */
+    deleteGuide(guideId: string): Promise<void>;
+    /**
+     * Get steps for a guide.
+     *
+     * @param guideId - Guide ID
+     * @returns Array of steps
+     *
+     * @example
+     * ```typescript
+     * const steps = await census.getGuideSteps('guide_123');
+     * ```
+     */
+    getGuideSteps(guideId: string): Promise<GuideStep[]>;
+    /**
+     * Add a step to a guide.
+     * Requires guides:create or guides:admin scope.
+     *
+     * @param guideId - Guide ID
+     * @param options - Step creation options
+     * @returns Created step
+     *
+     * @example
+     * ```typescript
+     * const step = await census.addGuideStep('guide_123', {
+     *   stepType: 'tooltip',
+     *   selectorStrategy: { css: '.welcome-button' },
+     *   richContent: {
+     *     title: 'Welcome!',
+     *     body: 'Click here to get started',
+     *   },
+     * });
+     * ```
+     */
+    addGuideStep(guideId: string, options: CreateGuideStepOptions): Promise<GuideStep>;
+    /**
+     * Update a guide step.
+     * Requires guides:create or guides:admin scope.
+     *
+     * @param guideId - Guide ID
+     * @param stepId - Step ID
+     * @param options - Update options
+     * @returns Updated step
+     *
+     * @example
+     * ```typescript
+     * const step = await census.updateGuideStep('guide_123', 'step_456', {
+     *   richContent: { title: 'Updated title' },
+     * });
+     * ```
+     */
+    updateGuideStep(guideId: string, stepId: string, options: UpdateGuideStepOptions): Promise<GuideStep>;
+    /**
+     * Delete a guide step.
+     * Requires guides:create or guides:admin scope.
+     *
+     * @param guideId - Guide ID
+     * @param stepId - Step ID
+     *
+     * @example
+     * ```typescript
+     * await census.deleteGuideStep('guide_123', 'step_456');
+     * ```
+     */
+    deleteGuideStep(guideId: string, stepId: string): Promise<void>;
+    /**
+     * Reorder steps in a guide.
+     * Requires guides:create or guides:admin scope.
+     *
+     * @param guideId - Guide ID
+     * @param stepOrder - Array of { id, sort_order } to define new order
+     * @returns Updated steps
+     *
+     * @example
+     * ```typescript
+     * const steps = await census.reorderGuideSteps('guide_123', [
+     *   { id: 'step_a', sort_order: 0 },
+     *   { id: 'step_b', sort_order: 1 },
+     *   { id: 'step_c', sort_order: 2 },
+     * ]);
+     * ```
+     */
+    reorderGuideSteps(guideId: string, stepOrder: Array<{
+        id: string;
+        sort_order: number;
+    }>): Promise<GuideStep[]>;
+    /**
+     * Track a guide analytics event.
+     * Used to track user progress through guides.
+     *
+     * @param event - Guide analytics event
+     *
+     * @example
+     * ```typescript
+     * await census.trackGuideEvent({
+     *   guideId: 'guide_123',
+     *   eventType: 'step_completed',
+     *   stepId: 'step_456',
+     *   stepIndex: 2,
+     *   sessionId: 'session_789',
+     * });
+     * ```
+     */
+    trackGuideEvent(event: GuideAnalyticsEvent): Promise<void>;
+    /**
+     * Mark a guide as completed for the current user.
+     * Prevents the guide from showing again.
+     *
+     * @param guideId - ID of the guide to mark as completed
+     *
+     * @example
+     * ```typescript
+     * await census.markGuideCompleted('guide_123');
      * ```
      */
     markGuideCompleted(guideId: string): Promise<void>;
@@ -880,6 +1338,42 @@ declare function useArticle(slugOrId: string): {
     error: Error | null;
     refetch: () => Promise<void>;
 };
+/**
+ * Hook for fetching feature groups with their features.
+ * Used by the HelpCenter component for navigation.
+ *
+ * @returns Object with feature groups data and loading state
+ *
+ * @example
+ * ```tsx
+ * function FeatureNav() {
+ *   const { featureGroups, isLoading } = useFeatureGroups();
+ *
+ *   if (isLoading) return <p>Loading...</p>;
+ *
+ *   return (
+ *     <nav>
+ *       {featureGroups.map(group => (
+ *         <div key={group.id}>
+ *           <h3>{group.name}</h3>
+ *           <ul>
+ *             {group.features.map(feature => (
+ *               <li key={feature.id}>{feature.name}</li>
+ *             ))}
+ *           </ul>
+ *         </div>
+ *       ))}
+ *     </nav>
+ *   );
+ * }
+ * ```
+ */
+declare function useFeatureGroups(): {
+    featureGroups: FeatureGroup[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
 /**
  * Hook for fetching the current user's submitted requests.
  *
@@ -943,6 +1437,168 @@ declare function useTrack(): {
         properties?: Record<string, unknown>;
     }>) => Promise<void>;
 };
+/**
+ * Hook for fetching guides.
+ *
+ * @param options - Query options (optional)
+ * @returns Object with guides data and loading state
+ *
+ * @example
+ * ```tsx
+ * function GuidesList() {
+ *   const { guides, isLoading, completedGuides } = useGuides({
+ *     url: window.location.href,
+ *   });
+ *
+ *   if (isLoading) return <p>Loading...</p>;
+ *
+ *   return (
+ *     <ul>
+ *       {guides.map(guide => (
+ *         <li key={guide.id}>
+ *           {guide.name}
+ *           {completedGuides.includes(guide.id) && ' (completed)'}
+ *         </li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useGuides(options?: GuidesOptions): {
+    guides: Guide[];
+    completedGuides: string[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+/**
+ * Hook for the Guide Builder - manages creation and editing of guides.
+ *
+ * @returns Object with guide builder state and actions
+ *
+ * @example
+ * ```tsx
+ * function GuideBuilderUI() {
+ *   const {
+ *     guide,
+ *     steps,
+ *     isLoading,
+ *     isSaving,
+ *     createGuide,
+ *     updateGuide,
+ *     addStep,
+ *     updateStep,
+ *     deleteStep,
+ *     reorderSteps,
+ *     publishGuide,
+ *   } = useGuideBuilder();
+ *
+ *   const handleCreateGuide = async () => {
+ *     await createGuide({
+ *       name: 'My Tour',
+ *       slug: 'my-tour',
+ *     });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleCreateGuide} disabled={isSaving}>
+ *         Create Guide
+ *       </button>
+ *       {guide && (
+ *         <div>
+ *           <h2>{guide.name}</h2>
+ *           <p>{steps.length} steps</p>
+ *         </div>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useGuideBuilder(): {
+    guide: Guide | null;
+    steps: GuideStep[];
+    selectedStep: GuideStep | null;
+    selectedStepId: string | null;
+    isLoading: boolean;
+    isSaving: boolean;
+    error: Error | null;
+    isReady: boolean;
+    hasUnsavedChanges: boolean;
+    loadGuide: (guideId: string) => Promise<Guide | null>;
+    createGuide: (options: CreateGuideOptions) => Promise<Guide>;
+    updateGuide: (options: UpdateGuideOptions) => Promise<Guide>;
+    publishGuide: () => Promise<Guide>;
+    unpublishGuide: () => Promise<Guide>;
+    deleteGuide: () => Promise<void>;
+    addStep: (options: CreateGuideStepOptions) => Promise<GuideStep>;
+    updateStep: (stepId: string, options: UpdateGuideStepOptions) => Promise<GuideStep>;
+    deleteStep: (stepId: string) => Promise<void>;
+    reorderSteps: (newOrder: Array<{
+        id: string;
+        sort_order: number;
+    }>) => Promise<GuideStep[]>;
+    moveStepUp: (stepId: string) => Promise<GuideStep[] | undefined>;
+    moveStepDown: (stepId: string) => Promise<GuideStep[] | undefined>;
+    setSelectedStepId: react.Dispatch<react.SetStateAction<string | null>>;
+    reset: () => void;
+};
+/**
+ * Hook for rendering guides - manages playback state for the GuideRenderer.
+ *
+ * @returns Object with guide renderer state and controls
+ *
+ * @example
+ * ```tsx
+ * function GuidePlayer() {
+ *   const {
+ *     activeGuide,
+ *     currentStepIndex,
+ *     isPlaying,
+ *     startGuide,
+ *     nextStep,
+ *     prevStep,
+ *     dismiss,
+ *   } = useGuideRenderer();
+ *
+ *   if (!activeGuide || !isPlaying) return null;
+ *
+ *   return (
+ *     <GuideRenderer
+ *       guide={activeGuide}
+ *       onComplete={() => dismiss()}
+ *       onDismiss={() => dismiss()}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function useGuideRenderer(): {
+    activeGuide: Guide | null;
+    currentStep: GuideStep | null;
+    currentStepIndex: number;
+    totalSteps: number;
+    isPlaying: boolean;
+    isFirstStep: boolean;
+    isLastStep: boolean;
+    isReady: boolean;
+    startGuide: (guide: Guide, startStep?: number) => void;
+    nextStep: () => void;
+    prevStep: () => void;
+    goToStep: (stepIndex: number) => void;
+    dismiss: () => void;
+    pause: () => void;
+    resume: () => void;
+    trackStepView: (guide: Guide, stepIndex: number) => Promise<void>;
+    trackGuideComplete: (guide: Guide) => Promise<void>;
+    trackGuideDismiss: (guide: Guide, stepIndex: number) => Promise<void>;
+    completedGuideIds: string[];
+    dismissedGuideIds: string[];
+    isGuideCompleted: (guideId: string) => boolean;
+    isGuideDismissed: (guideId: string) => boolean;
+};
 
 /**
  * Floating feedback button component.
@@ -1010,4 +1666,439 @@ declare function KnowledgeBase({ showSearch, showCategories, defaultCategory, th
  */
 declare function Requests({ status, type, limit, className, showEmptyState, onRequestClick, }: RequestsProps): react_jsx_runtime.JSX.Element | null;
 
-export { type Article, type ArticlesOptions, CensusProvider, type CensusProviderProps, type CensusTheme, FeedbackButton, type FeedbackButtonProps, type FeedbackOptions, type FeedbackType, KnowledgeBase, type KnowledgeBaseProps, type Position, type Request, Requests, type RequestsOptions, type RequestsProps, type UserIdentity, useArticle, useArticles, useCensus, useCensusContext, useFeedback, useIdentify, useRequests, useTrack };
+/**
+ * Unified help center component with left navigation showing feature groups.
+ *
+ * @example
+ * ```tsx
+ * import { HelpCenter } from '@census-ai/census-sdk/react';
+ *
+ * function HelpPage() {
+ *   return (
+ *     <HelpCenter
+ *       tabs={['articles', 'requests']}
+ *       showSearch
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function HelpCenter({ tabs, defaultTab, tabLabels, showSearch, showCategories: _showCategories, // Reserved for future use
+theme: themeProp, className, onArticleView, onRequestClick, onTabChange, }: HelpCenterProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Props for the GuideBuilder component
+ */
+interface GuideBuilderProps {
+    /**
+     * Whether the builder is open
+     */
+    isOpen?: boolean;
+    /**
+     * Callback when builder is closed
+     */
+    onClose?: () => void;
+    /**
+     * Guide ID to edit (optional - if not provided, creates new guide)
+     */
+    guideId?: string;
+    /**
+     * Callback when guide is saved
+     */
+    onSave?: (guide: Guide) => void;
+    /**
+     * Callback when guide is published
+     */
+    onPublish?: (guide: Guide) => void;
+    /**
+     * Custom trigger element
+     */
+    trigger?: ReactNode;
+    /**
+     * Custom CSS class for the modal
+     */
+    className?: string;
+}
+/**
+ * Guide Builder Component
+ *
+ * A full-screen overlay for creating and editing guides.
+ * This is a shell component - the full UI will be implemented in Phase 3.
+ *
+ * @example
+ * ```tsx
+ * // Controlled mode
+ * <GuideBuilder
+ *   isOpen={showBuilder}
+ *   onClose={() => setShowBuilder(false)}
+ *   onSave={(guide) => console.log('Saved:', guide)}
+ * />
+ *
+ * // With trigger
+ * <GuideBuilder
+ *   trigger={<button>Create Guide</button>}
+ *   onSave={(guide) => console.log('Saved:', guide)}
+ * />
+ * ```
+ */
+declare function GuideBuilder({ isOpen: controlledIsOpen, onClose, guideId, onSave, onPublish, trigger, className, }: GuideBuilderProps): react_jsx_runtime.JSX.Element | null;
+
+interface TooltipStepProps {
+    /**
+     * The step data
+     */
+    step: GuideStep;
+    /**
+     * Current step index (0-based)
+     */
+    currentStep: number;
+    /**
+     * Total number of steps
+     */
+    totalSteps: number;
+    /**
+     * Callback when advancing to next step
+     */
+    onNext: () => void;
+    /**
+     * Callback when going to previous step
+     */
+    onPrev: () => void;
+    /**
+     * Callback when dismissing the guide
+     */
+    onDismiss: () => void;
+    /**
+     * Callback for custom button actions
+     */
+    onCustomAction?: (actionName: string) => void;
+    /**
+     * Whether to show progress indicator
+     */
+    showProgress?: boolean;
+    /**
+     * Global style overrides
+     */
+    globalStyle?: GuideStepStyleConfig;
+    /**
+     * Z-index for the tooltip
+     */
+    zIndex?: number;
+}
+declare function TooltipStep({ step, currentStep, totalSteps, onNext, onPrev, onDismiss, onCustomAction, showProgress, globalStyle, zIndex, }: TooltipStepProps): react_jsx_runtime.JSX.Element;
+
+interface ModalStepProps {
+    /**
+     * The step data
+     */
+    step: GuideStep;
+    /**
+     * Current step index (0-based)
+     */
+    currentStep: number;
+    /**
+     * Total number of steps
+     */
+    totalSteps: number;
+    /**
+     * Callback when advancing to next step
+     */
+    onNext: () => void;
+    /**
+     * Callback when going to previous step
+     */
+    onPrev: () => void;
+    /**
+     * Callback when dismissing the guide
+     */
+    onDismiss: () => void;
+    /**
+     * Callback for custom button actions
+     */
+    onCustomAction?: (actionName: string) => void;
+    /**
+     * Whether to show progress indicator
+     */
+    showProgress?: boolean;
+    /**
+     * Global style overrides
+     */
+    globalStyle?: GuideStepStyleConfig;
+    /**
+     * Z-index for the modal
+     */
+    zIndex?: number;
+}
+declare function ModalStep({ step, currentStep, totalSteps, onNext, onPrev, onDismiss, onCustomAction, showProgress, globalStyle, zIndex, }: ModalStepProps): react_jsx_runtime.JSX.Element;
+
+interface SlideoutStepProps {
+    /**
+     * The step data
+     */
+    step: GuideStep;
+    /**
+     * Current step index (0-based)
+     */
+    currentStep: number;
+    /**
+     * Total number of steps
+     */
+    totalSteps: number;
+    /**
+     * Callback when advancing to next step
+     */
+    onNext: () => void;
+    /**
+     * Callback when going to previous step
+     */
+    onPrev: () => void;
+    /**
+     * Callback when dismissing the guide
+     */
+    onDismiss: () => void;
+    /**
+     * Callback for custom button actions
+     */
+    onCustomAction?: (actionName: string) => void;
+    /**
+     * Whether to show progress indicator
+     */
+    showProgress?: boolean;
+    /**
+     * Global style overrides
+     */
+    globalStyle?: GuideStepStyleConfig;
+    /**
+     * Z-index for the slideout
+     */
+    zIndex?: number;
+}
+declare function SlideoutStep({ step, currentStep, totalSteps, onNext, onPrev, onDismiss, onCustomAction, showProgress, globalStyle, zIndex, }: SlideoutStepProps): react_jsx_runtime.JSX.Element;
+
+interface HotspotStepProps {
+    /**
+     * The step data
+     */
+    step: GuideStep;
+    /**
+     * Current step index (0-based)
+     */
+    currentStep: number;
+    /**
+     * Total number of steps
+     */
+    totalSteps: number;
+    /**
+     * Callback when advancing to next step
+     */
+    onNext: () => void;
+    /**
+     * Callback when going to previous step
+     */
+    onPrev: () => void;
+    /**
+     * Callback when dismissing the guide
+     */
+    onDismiss: () => void;
+    /**
+     * Callback for custom button actions
+     */
+    onCustomAction?: (actionName: string) => void;
+    /**
+     * Whether to show progress indicator
+     */
+    showProgress?: boolean;
+    /**
+     * Global style overrides
+     */
+    globalStyle?: GuideStepStyleConfig;
+    /**
+     * Z-index for the hotspot
+     */
+    zIndex?: number;
+}
+declare function HotspotStep({ step, currentStep, totalSteps, onNext, onPrev, onDismiss, onCustomAction, showProgress, globalStyle, zIndex, }: HotspotStepProps): react_jsx_runtime.JSX.Element | null;
+
+interface BannerStepProps {
+    /**
+     * The step data
+     */
+    step: GuideStep;
+    /**
+     * Current step index (0-based)
+     */
+    currentStep: number;
+    /**
+     * Total number of steps
+     */
+    totalSteps: number;
+    /**
+     * Callback when advancing to next step
+     */
+    onNext: () => void;
+    /**
+     * Callback when going to previous step
+     */
+    onPrev: () => void;
+    /**
+     * Callback when dismissing the guide
+     */
+    onDismiss: () => void;
+    /**
+     * Callback for custom button actions
+     */
+    onCustomAction?: (actionName: string) => void;
+    /**
+     * Whether to show progress indicator
+     */
+    showProgress?: boolean;
+    /**
+     * Global style overrides
+     */
+    globalStyle?: GuideStepStyleConfig;
+    /**
+     * Z-index for the banner
+     */
+    zIndex?: number;
+}
+declare function BannerStep({ step, currentStep, totalSteps, onNext, onPrev, onDismiss, onCustomAction, showProgress, globalStyle, zIndex, }: BannerStepProps): react_jsx_runtime.JSX.Element | null;
+
+interface BackdropProps {
+    /**
+     * Whether the backdrop is visible
+     */
+    visible: boolean;
+    /**
+     * Element to spotlight (cut out of backdrop)
+     */
+    spotlightElement?: Element | null;
+    /**
+     * Padding around the spotlighted element
+     */
+    spotlightPadding?: number;
+    /**
+     * Callback when clicking the backdrop (outside spotlight)
+     */
+    onClick?: () => void;
+    /**
+     * Whether clicking backdrop dismisses the guide
+     */
+    dismissOnClick?: boolean;
+    /**
+     * Custom z-index
+     */
+    zIndex?: number;
+    /**
+     * Backdrop opacity (0-1)
+     */
+    opacity?: number;
+}
+declare function Backdrop({ visible, spotlightElement, spotlightPadding, onClick, dismissOnClick, zIndex, opacity, }: BackdropProps): react_jsx_runtime.JSX.Element | null;
+
+interface StepButtonsProps {
+    /**
+     * Button configuration from step
+     */
+    buttons?: GuideStepRichContent['buttons'];
+    /**
+     * Current step index
+     */
+    currentStep: number;
+    /**
+     * Total number of steps
+     */
+    totalSteps: number;
+    /**
+     * Whether this is the last step
+     */
+    isLastStep: boolean;
+    /**
+     * Callback for next action
+     */
+    onNext: () => void;
+    /**
+     * Callback for previous action
+     */
+    onPrev: () => void;
+    /**
+     * Callback for dismiss action
+     */
+    onDismiss: () => void;
+    /**
+     * Callback for custom actions
+     */
+    onCustomAction?: (actionName: string) => void;
+    /**
+     * Accent color for primary buttons
+     */
+    accentColor?: string;
+}
+declare function StepButtons({ buttons, currentStep, isLastStep, onNext, onPrev, onDismiss, onCustomAction, accentColor, }: StepButtonsProps): react_jsx_runtime.JSX.Element;
+
+interface StepContentProps {
+    /**
+     * The step data
+     */
+    step: GuideStep;
+    /**
+     * Text color for content
+     */
+    textColor?: string;
+    /**
+     * Whether to show the title
+     */
+    showTitle?: boolean;
+}
+declare function StepContent({ step, textColor, showTitle, }: StepContentProps): react_jsx_runtime.JSX.Element;
+
+interface GuideRendererProps {
+    /**
+     * The guide to render
+     */
+    guide: Guide;
+    /**
+     * Callback when guide is completed
+     */
+    onComplete?: (guide: Guide) => void;
+    /**
+     * Callback when guide is dismissed (skipped)
+     */
+    onDismiss?: (guide: Guide, step: number) => void;
+    /**
+     * Callback when a step changes
+     */
+    onStepChange?: (step: number, totalSteps: number) => void;
+    /**
+     * Callback for custom button actions
+     */
+    onCustomAction?: (actionName: string, step: GuideStep) => void;
+    /**
+     * Global style overrides
+     */
+    globalStyle?: GuideStepStyleConfig;
+    /**
+     * Starting step index
+     */
+    startStep?: number;
+    /**
+     * Z-index base for guide elements
+     */
+    zIndex?: number;
+}
+/**
+ * GuideRenderer - Displays a guide step by step
+ *
+ * Renders the appropriate step type component based on the step's step_type field.
+ *
+ * @example
+ * ```tsx
+ * <GuideRenderer
+ *   guide={myGuide}
+ *   onComplete={(guide) => console.log('Completed:', guide.name)}
+ *   onDismiss={(guide, step) => console.log('Dismissed at step:', step)}
+ * />
+ * ```
+ */
+declare function GuideRenderer({ guide, onComplete, onDismiss, onStepChange, onCustomAction, globalStyle, startStep, zIndex, }: GuideRendererProps): react_jsx_runtime.JSX.Element | null;
+
+export { type AdvanceTrigger, type Article, type ArticlesOptions, Backdrop, BannerStep, CensusProvider, type CensusProviderProps, type CensusTheme, type CreateGuideOptions, type CreateGuideStepOptions, type Feature, type FeatureGroup, type FeatureGroupsResponse, FeedbackButton, type FeedbackButtonProps, type FeedbackOptions, type FeedbackType, type Guide, GuideBuilder, type GuideFormType, GuideRenderer, type GuideStatus, type GuideStep, type GuideStepAdvanceConfig, type GuideStepDisplayConfig, type GuideStepRichContent, type GuideStepStyleConfig, type GuideStepType, type GuideTriggerType, type GuidesOptions, type GuidesResponse, HelpCenter, type HelpCenterProps, type HelpCenterTab, HotspotStep, KnowledgeBase, type KnowledgeBaseProps, ModalStep, type Position, type Request, Requests, type RequestsOptions, type RequestsProps, type SelectorStrategy, SlideoutStep, StepButtons, StepContent, type TooltipPosition, TooltipStep, type UpdateGuideOptions, type UpdateGuideStepOptions, type UserIdentity, useArticle, useArticles, useCensus, useCensusContext, useFeatureGroups, useFeedback, useGuideBuilder, useGuideRenderer, useGuides, useIdentify, useRequests, useTrack };