nucleus-core-ts 0.9.781 → 0.9.783

package/dist/fe/components/IntegrationsPage/theme/index.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Every class the panel paints with, in one place.
+ *
+ * Light is the base and `dark:` is the override, so nothing renders unstyled in
+ * either theme. Sizing is mobile-first: the base classes are what a 320px phone
+ * gets, and each breakpoint adds room rather than repairing damage.
+ *
+ * An app can replace any slice of this with {@link extendIntegrationsTheme}
+ * without forking the components.
+ */
+export type IntegrationsPageTheme = {
+    container: string;
+    header: {
+        wrapper: string;
+        title: string;
+        subtitle: string;
+        actions: string;
+    };
+    layout: {
+        split: string;
+        aside: string;
+        main: string;
+    };
+    card: {
+        wrapper: string;
+        header: string;
+        title: string;
+        body: string;
+        footer: string;
+    };
+    list: {
+        wrapper: string;
+        item: string;
+        itemSelected: string;
+        itemTitle: string;
+        itemMeta: string;
+        empty: string;
+        sentinel: string;
+    };
+    tabs: {
+        wrapper: string;
+        button: string;
+        active: string;
+        inactive: string;
+    };
+    field: {
+        wrapper: string;
+        label: string;
+        input: string;
+        hint: string;
+        error: string;
+    };
+    button: {
+        primary: string;
+        secondary: string;
+        ghost: string;
+        danger: string;
+    };
+    badge: {
+        base: string;
+        neutral: string;
+        success: string;
+        warning: string;
+        danger: string;
+        info: string;
+    };
+    stat: {
+        grid: string;
+        cell: string;
+        value: string;
+        label: string;
+    };
+    notice: {
+        info: string;
+        warning: string;
+        danger: string;
+        title: string;
+        body: string;
+    };
+    code: string;
+    skeleton: {
+        line: string;
+        block: string;
+    };
+    progress: {
+        track: string;
+        bar: string;
+        label: string;
+    };
+};
+export declare const integrationsPageTheme: IntegrationsPageTheme;
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+/**
+ * Overrides a slice of the theme, leaving the rest intact.
+ *
+ * One level of nesting is all the theme has, so a shallow merge per group is
+ * exactly right — and it means an app overriding one badge colour does not have
+ * to restate the other five.
+ */
+export declare function extendIntegrationsTheme(overrides: DeepPartial<IntegrationsPageTheme>): IntegrationsPageTheme;
+export {};

package/dist/fe/components/IntegrationsPage/theme/index.js

@@ -0,0 +1,113 @@
+/**
+ * Every class the panel paints with, in one place.
+ *
+ * Light is the base and `dark:` is the override, so nothing renders unstyled in
+ * either theme. Sizing is mobile-first: the base classes are what a 320px phone
+ * gets, and each breakpoint adds room rather than repairing damage.
+ *
+ * An app can replace any slice of this with {@link extendIntegrationsTheme}
+ * without forking the components.
+ */ /** Shared so a control and its skeleton cannot drift apart in height. */ const CONTROL = 'h-10 rounded-lg text-sm sm:h-9';
+export const integrationsPageTheme = {
+    container: 'flex flex-col gap-4 text-slate-900 sm:gap-5 dark:text-slate-100',
+    header: {
+        wrapper: 'flex flex-col gap-2 sm:flex-row sm:items-end sm:justify-between',
+        title: 'font-semibold text-lg tracking-tight sm:text-xl',
+        subtitle: 'text-slate-600 text-sm dark:text-slate-400',
+        actions: 'flex flex-wrap items-center gap-2'
+    },
+    // One column on a phone; the connection list becomes a rail from lg upward,
+    // where there is finally room for both without either being cramped.
+    layout: {
+        split: 'grid grid-cols-1 gap-4 lg:grid-cols-[minmax(0,20rem)_minmax(0,1fr)] lg:gap-5',
+        aside: 'flex min-w-0 flex-col gap-3',
+        main: 'flex min-w-0 flex-col gap-4'
+    },
+    card: {
+        wrapper: 'rounded-xl border border-slate-200 bg-white shadow-sm dark:border-slate-800 dark:bg-slate-900',
+        header: 'flex flex-col gap-2 border-slate-200 border-b px-4 py-3 sm:flex-row sm:items-center sm:justify-between dark:border-slate-800',
+        title: 'font-medium text-slate-900 text-sm dark:text-slate-100',
+        body: 'flex flex-col gap-3 p-4',
+        footer: 'flex flex-wrap items-center justify-end gap-2 border-slate-200 border-t px-4 py-3 dark:border-slate-800'
+    },
+    list: {
+        wrapper: 'flex flex-col gap-1.5',
+        item: 'flex w-full flex-col gap-0.5 rounded-lg border border-transparent px-3 py-2.5 text-left transition-colors hover:bg-slate-100 dark:hover:bg-slate-800',
+        itemSelected: 'border-sky-300 bg-sky-50 hover:bg-sky-50 dark:border-sky-700 dark:bg-sky-950 dark:hover:bg-sky-950',
+        itemTitle: 'truncate font-medium text-slate-900 text-sm dark:text-slate-100',
+        itemMeta: 'truncate text-slate-500 text-xs dark:text-slate-400',
+        empty: 'rounded-lg border border-slate-200 border-dashed px-4 py-8 text-center text-slate-500 text-sm dark:border-slate-700 dark:text-slate-400',
+        // Watched by the infinite scroller; the next page is requested when it appears.
+        sentinel: 'h-8 w-full shrink-0'
+    },
+    tabs: {
+        wrapper: 'flex gap-1 overflow-x-auto rounded-lg border border-slate-200 bg-slate-50 p-1 dark:border-slate-800 dark:bg-slate-900',
+        button: 'shrink-0 rounded-md px-3 py-1.5 font-medium text-sm transition-colors focus-visible:outline focus-visible:outline-2 focus-visible:outline-sky-500 focus-visible:outline-offset-2',
+        active: 'bg-white text-slate-900 shadow-sm dark:bg-slate-800 dark:text-slate-100',
+        inactive: 'text-slate-600 hover:text-slate-900 dark:text-slate-400 dark:hover:text-slate-100'
+    },
+    field: {
+        wrapper: 'flex flex-col gap-1.5',
+        label: 'font-medium text-slate-700 text-xs dark:text-slate-300',
+        input: `w-full border border-slate-300 bg-white px-3 text-slate-900 outline-none transition-colors placeholder:text-slate-400 focus:border-sky-500 focus:ring-2 focus:ring-sky-500/20 disabled:opacity-60 dark:border-slate-700 dark:bg-slate-950 dark:text-slate-100 dark:placeholder:text-slate-500 ${CONTROL}`,
+        hint: 'text-slate-500 text-xs dark:text-slate-400',
+        error: 'text-rose-600 text-xs dark:text-rose-400'
+    },
+    button: {
+        primary: `inline-flex items-center justify-center gap-1.5 bg-sky-600 px-3.5 font-medium text-white transition-colors hover:bg-sky-700 disabled:opacity-50 dark:bg-sky-500 dark:hover:bg-sky-400 dark:text-slate-950 ${CONTROL}`,
+        secondary: `inline-flex items-center justify-center gap-1.5 border border-slate-300 bg-white px-3.5 font-medium text-slate-700 transition-colors hover:bg-slate-50 disabled:opacity-50 dark:border-slate-700 dark:bg-slate-900 dark:text-slate-200 dark:hover:bg-slate-800 ${CONTROL}`,
+        ghost: `inline-flex items-center justify-center gap-1.5 px-2.5 font-medium text-slate-600 transition-colors hover:bg-slate-100 hover:text-slate-900 disabled:opacity-50 dark:text-slate-400 dark:hover:bg-slate-800 dark:hover:text-slate-100 ${CONTROL}`,
+        danger: `inline-flex items-center justify-center gap-1.5 bg-rose-600 px-3.5 font-medium text-white transition-colors hover:bg-rose-700 disabled:opacity-50 dark:bg-rose-600 dark:hover:bg-rose-500 ${CONTROL}`
+    },
+    badge: {
+        base: 'inline-flex items-center gap-1 rounded-full border px-2 py-0.5 font-medium text-xs',
+        neutral: 'border-slate-200 bg-slate-100 text-slate-700 dark:border-slate-700 dark:bg-slate-800 dark:text-slate-300',
+        success: 'border-emerald-200 bg-emerald-50 text-emerald-700 dark:border-emerald-800 dark:bg-emerald-950 dark:text-emerald-400',
+        warning: 'border-amber-200 bg-amber-50 text-amber-700 dark:border-amber-800 dark:bg-amber-950 dark:text-amber-400',
+        danger: 'border-rose-200 bg-rose-50 text-rose-700 dark:border-rose-800 dark:bg-rose-950 dark:text-rose-400',
+        info: 'border-sky-200 bg-sky-50 text-sky-700 dark:border-sky-800 dark:bg-sky-950 dark:text-sky-400'
+    },
+    stat: {
+        grid: 'grid grid-cols-2 gap-2 xs:grid-cols-3 sm:grid-cols-4 lg:grid-cols-6',
+        cell: 'flex flex-col items-center gap-0.5 rounded-lg border border-slate-200 bg-white px-2 py-3 text-center dark:border-slate-800 dark:bg-slate-900',
+        value: 'font-semibold text-lg tabular-nums',
+        label: 'text-[11px] text-slate-500 leading-tight dark:text-slate-400'
+    },
+    notice: {
+        info: 'rounded-lg border border-sky-200 bg-sky-50 p-3 dark:border-sky-900 dark:bg-sky-950',
+        warning: 'rounded-lg border border-amber-200 bg-amber-50 p-3 dark:border-amber-900 dark:bg-amber-950',
+        danger: 'rounded-lg border border-rose-200 bg-rose-50 p-3 dark:border-rose-900 dark:bg-rose-950',
+        title: 'font-medium text-sm',
+        body: 'mt-0.5 text-sm leading-relaxed opacity-90'
+    },
+    code: 'block overflow-x-auto rounded-lg border border-slate-200 bg-slate-50 p-3 font-mono text-[11px] text-slate-700 leading-relaxed sm:text-xs dark:border-slate-800 dark:bg-slate-950 dark:text-slate-300',
+    skeleton: {
+        line: 'h-3 animate-pulse rounded bg-slate-200 dark:bg-slate-800',
+        block: 'animate-pulse rounded-lg bg-slate-200 dark:bg-slate-800'
+    },
+    progress: {
+        track: 'h-1.5 w-full overflow-hidden rounded-full bg-slate-200 dark:bg-slate-800',
+        bar: 'h-full rounded-full bg-sky-600 transition-[width] duration-300 ease-out dark:bg-sky-500',
+        label: 'text-slate-600 text-xs tabular-nums dark:text-slate-400'
+    }
+};
+/**
+ * Overrides a slice of the theme, leaving the rest intact.
+ *
+ * One level of nesting is all the theme has, so a shallow merge per group is
+ * exactly right — and it means an app overriding one badge colour does not have
+ * to restate the other five.
+ */ export function extendIntegrationsTheme(overrides) {
+    const base = integrationsPageTheme;
+    const merged = {
+        ...base
+    };
+    for (const [group, value] of Object.entries(overrides)){
+        const current = base[group];
+        merged[group] = value && typeof value === 'object' && current && typeof current === 'object' ? {
+            ...current,
+            ...value
+        } : value;
+    }
+    return merged;
+}

package/dist/fe/components/IntegrationsPage/types/actions.d.ts

@@ -0,0 +1,91 @@
+import type { IntegrationEndpoint, IntegrationMapping, IntegrationRun, IntegrationSource } from './records';
+import type { ConnectionTestValue, EndpointSampleValue, RunPlanValue, RunProgressValue } from './results';
+/**
+ * One page of a server-driven list.
+ *
+ * Filtering, searching, sorting and paging all happen on the server. A list that
+ * pages on the client has already fetched everything, which stops being viable
+ * at the first customer with real data.
+ */
+export type ListQuery = {
+    page?: number;
+    limit?: number;
+    search?: string;
+    sort?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    }[];
+    filters?: unknown[];
+};
+export type ListResult<T> = {
+    items: T[];
+    meta?: {
+        page?: number;
+        limit?: number;
+        totalItems?: number;
+        totalPages?: number;
+        hasNextPage?: boolean;
+    };
+};
+export type IntegrationsActions = {
+    listSources: (query: ListQuery) => Promise<ListResult<IntegrationSource>>;
+    saveSource: (source: Partial<IntegrationSource>) => Promise<IntegrationSource | null>;
+    deleteSource: (id: string) => Promise<boolean>;
+    /** Write-only: the value goes in, only a masked preview comes back. */
+    saveCredentials: (sourceId: string, values: {
+        token?: string;
+        oauthClientSecret?: string;
+        oauthPassword?: string;
+    }) => Promise<Record<string, string | null>>;
+    testSource: (sourceId: string) => Promise<ConnectionTestValue>;
+    listEndpoints: (sourceId: string, query: ListQuery) => Promise<ListResult<IntegrationEndpoint>>;
+    saveEndpoint: (endpoint: Partial<IntegrationEndpoint>) => Promise<IntegrationEndpoint | null>;
+    deleteEndpoint: (id: string) => Promise<boolean>;
+    sampleEndpoint: (endpointId: string, pathParams?: Record<string, string>) => Promise<EndpointSampleValue>;
+    /**
+     * Mappings of one CONNECTION.
+     *
+     * Scoped by source rather than by a list of endpoint ids: the panel only ever
+     * holds the current page of endpoints, so passing ids would silently hide
+     * every mapping whose endpoint had not been paged in yet. Resolving that join
+     * is the app's job, which is the side that can ask the server for it.
+     */
+    listMappings: (sourceId: string, query: ListQuery) => Promise<ListResult<IntegrationMapping>>;
+    saveMapping: (mapping: Partial<IntegrationMapping>) => Promise<IntegrationMapping | null>;
+    deleteMapping: (id: string) => Promise<boolean>;
+    previewRun: (mappingId: string) => Promise<{
+        plan: RunPlanValue | null;
+        error?: string;
+    }>;
+    startRun: (mappingId: string, confirm?: boolean) => Promise<{
+        runId: string | null;
+        error?: string;
+        needsConfirm?: boolean;
+    }>;
+    cancelRun: (runId: string) => Promise<boolean>;
+    revertRun: (runId: string, force?: boolean) => Promise<{
+        ok: boolean;
+        message: string;
+        conflicts?: {
+            id: string;
+            reason: string;
+        }[];
+    }>;
+    listRuns: (query: ListQuery & {
+        mappingId?: string;
+    }) => Promise<ListResult<IntegrationRun>>;
+    /** Target entities this app allows an import to write into, with their columns. */
+    listTargets: () => Promise<{
+        entity: string;
+        label: string;
+        fields: string[];
+    }[]>;
+};
+export type IntegrationsPageProps = {
+    title?: string;
+    subtitle?: string;
+    className?: string;
+    actions: IntegrationsActions;
+    /** Realtime run progress, when the app wires the pub/sub topic. */
+    onSubscribeProgress?: (handler: (progress: RunProgressValue) => void) => () => void;
+};

package/dist/fe/components/IntegrationsPage/types/actions.js

@@ -0,0 +1 @@
+export { };

package/dist/fe/components/IntegrationsPage/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './actions';
+export * from './records';
+export * from './results';

package/dist/fe/components/IntegrationsPage/types/index.js

@@ -0,0 +1,3 @@
+export * from './actions';
+export * from './records';
+export * from './results';

package/dist/fe/components/IntegrationsPage/types/records.d.ts

@@ -0,0 +1,139 @@
+/**
+ * The panel's contract with whatever app mounts it.
+ *
+ * Every call is an injected action, exactly like the other pages in this kit —
+ * the component knows the SHAPE of an integration but nothing about how this
+ * particular app talks to its server.
+ *
+ * The record types below deliberately mirror the system tables rather than
+ * re-modelling them, so a column added to the framework does not need a second
+ * definition here to become visible.
+ */
+import type { RunIssueValue } from './results';
+export type IntegrationAuthType = 'none' | 'bearer' | 'api_key' | 'basic' | 'oauth2';
+export type IntegrationSource = {
+    id: string;
+    name: string;
+    slug: string;
+    /** Any scheme, host and port. HTTPS is not required and must not be enforced. */
+    baseUrl: string;
+    description?: string | null;
+    enabled?: boolean;
+    authType: IntegrationAuthType;
+    /** Masked preview of the stored credential. The value itself never arrives. */
+    authTokenHint?: string | null;
+    authHeaderName?: string | null;
+    authQueryParam?: string | null;
+    extraHeaders?: Record<string, string> | null;
+    tokenUrl?: string | null;
+    oauthGrantType?: 'password' | 'client_credentials' | null;
+    oauthClientId?: string | null;
+    oauthClientSecretHint?: string | null;
+    oauthUsername?: string | null;
+    oauthPasswordHint?: string | null;
+    oauthScope?: string | null;
+    oauthClientAuth?: 'basic' | 'body' | null;
+    /** False turns off certificate verification for THIS source's requests only. */
+    tlsVerify?: boolean;
+    timeoutMs?: number | null;
+};
+export type PaginationKind = 'none' | 'page_number' | 'offset' | 'cursor' | 'link_header';
+/** Chosen explicitly. A wrong guess silently imports one page. */
+export type PaginationProfileValue = {
+    kind: PaginationKind;
+    pageParam?: string;
+    sizeParam?: string;
+    offsetParam?: string;
+    limitParam?: string;
+    cursorParam?: string;
+    nextCursorPath?: string;
+    pageSize?: number;
+    firstPage?: number;
+    totalPath?: string;
+    lastPagePath?: string;
+};
+/** Where one path/query parameter of an endpoint gets its value. */
+export type ParamBindingValue = {
+    param: string;
+    from: 'static';
+    value: string;
+} | {
+    param: string;
+    from: 'endpoint';
+    endpointId: string;
+    field: string;
+} | {
+    param: string;
+    from: 'entity';
+    entity: string;
+    field: string;
+};
+export type IntegrationEndpoint = {
+    id: string;
+    sourceId: string;
+    tag: string;
+    name?: string | null;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    description?: string | null;
+    queryParams?: Record<string, unknown> | null;
+    requestBody?: Record<string, unknown> | null;
+    paramBindings?: ParamBindingValue[] | null;
+    pagination?: PaginationProfileValue | null;
+    responseRootPath?: string | null;
+    sampleResponse?: {
+        records?: unknown[];
+    } | null;
+    enabled?: boolean;
+};
+export type MappingTransformValue = 'none' | 'trim' | 'upper' | 'lower' | 'toString' | 'toNumber' | 'toBoolean' | 'dateOnly';
+export type FieldMappingValue = {
+    source: string;
+    target: string;
+    transform?: MappingTransformValue;
+    constant?: string;
+    fallback?: string;
+};
+export type WriteModeValue = 'upsert' | 'append' | 'replace';
+export type MissingRecordPolicyValue = 'ignore' | 'deactivate' | 'delete';
+export type IntegrationMapping = {
+    id: string;
+    endpointId: string;
+    name: string;
+    targetEntity: string;
+    fieldMappings: FieldMappingValue[];
+    dedupSourceField?: string | null;
+    dedupTargetField?: string | null;
+    writeMode: WriteModeValue;
+    missingRecordPolicy: MissingRecordPolicyValue;
+    missingRecordColumn?: string | null;
+    missingRecordValue?: string | null;
+    lastRunAt?: string | null;
+    enabled?: boolean;
+};
+export type RunStatusValue = 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled' | 'reverted';
+export type IntegrationRun = {
+    id: string;
+    mappingId?: string | null;
+    targetEntity?: string | null;
+    writeMode?: WriteModeValue | null;
+    status: RunStatusValue;
+    trigger?: string | null;
+    totalFetched: number;
+    sourceReportedTotal?: number | null;
+    createdCount: number;
+    updatedCount: number;
+    skippedCount: number;
+    deletedCount: number;
+    deactivatedCount: number;
+    errorCount: number;
+    externalCallCount?: number;
+    issues?: RunIssueValue[] | null;
+    errors?: string[] | null;
+    cancelRequested?: boolean;
+    startedAt?: string | null;
+    finishedAt?: string | null;
+    preImagesExpireAt?: string | null;
+    revertedAt?: string | null;
+    createdAt?: string | null;
+};

package/dist/fe/components/IntegrationsPage/types/records.js

@@ -0,0 +1,11 @@
+/**
+ * The panel's contract with whatever app mounts it.
+ *
+ * Every call is an injected action, exactly like the other pages in this kit —
+ * the component knows the SHAPE of an integration but nothing about how this
+ * particular app talks to its server.
+ *
+ * The record types below deliberately mirror the system tables rather than
+ * re-modelling them, so a column added to the framework does not need a second
+ * definition here to become visible.
+ */ export { };

package/dist/fe/components/IntegrationsPage/types/results.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Shapes the panel RENDERS rather than stores: what a call reported, what a
+ * run would do, and how far a running one has got.
+ */
+import type { MissingRecordPolicyValue, WriteModeValue } from './records';
+export type RunIssueValue = {
+    sourceIndex: number;
+    kind: string;
+    message: string;
+    dedupKey?: string | null;
+};
+/** What a run would do, computed without writing. */
+export type RunPlanValue = {
+    targetEntity: string;
+    writeMode: WriteModeValue;
+    totalFetched: number;
+    reportedTotal: number | null;
+    toCreate: number;
+    toUpdate: number;
+    toSkip: number;
+    missing: number;
+    missingPolicy: MissingRecordPolicyValue;
+    existingCount: number;
+    dedupConfigured: boolean;
+    issues: RunIssueValue[];
+    warnings: string[];
+    sample: Record<string, unknown>[];
+};
+export type ConnectionTestValue = {
+    ok: boolean;
+    detail?: string;
+    error?: string;
+};
+export type EndpointSampleValue = {
+    ok: boolean;
+    status: number;
+    error: string | null;
+    recordCount: number;
+    sample: unknown[];
+    fields: string[];
+    /** Top-level keys of the raw body — the answer to "why 0 records". */
+    bodyKeys: string[];
+    bodyPreview: string | null;
+};
+/** How far a running import has got, as the server reports it. */
+export type RunProgressValue = {
+    runId: string;
+    phase: 'fetching' | 'mapping' | 'validating' | 'writing' | 'done';
+    processed?: number;
+    total?: number;
+    message?: string;
+};

package/dist/fe/components/IntegrationsPage/types/results.js

@@ -0,0 +1,4 @@
+/**
+ * Shapes the panel RENDERS rather than stores: what a call reported, what a
+ * run would do, and how far a running one has got.
+ */ /** How far a running import has got, as the server reports it. */ export { };

package/dist/fe/index.d.ts

@@ -21,6 +21,8 @@ export type { ForgotPasswordAction, ForgotPasswordFormProps, ForgotPasswordHeade
 export { ForgotPasswordPage, useForgotPasswordStore, } from './components/ForgotPasswordPage';
 export type { FormBuilderProps, FormFieldConfig, FormFieldProps, FormFieldRenderProps, FormFooterRenderProps, FormLayout, FormMode, FormSize, FormState, UseFormBuilderOptions, UseFormBuilderReturn, } from './components/FormBuilder';
 export { FormBuilder, FormField, formBuilderTheme, useFormBuilder, } from './components/FormBuilder';
+export type { ConnectionTab, IntegrationsActions, IntegrationsPageProps, IntegrationsPageTheme, } from './components/IntegrationsPage';
+export { extendIntegrationsTheme, IntegrationsPage, integrationsPageTheme, useIntegrationsStore, } from './components/IntegrationsPage';
 export type { LoginAction, LoginFeatureConfig, LoginFormData, LoginFormProps, LoginHeaderProps, LoginPageConfig, LoginPageProps, LoginPageVariant, LogoutAction, MeAction, } from './components/LoginPage';
 export { LoginPage, useLoginStore } from './components/LoginPage';
 export type { MagicLinkVerifyAction as MagicLinkVerifyPageAction, MagicLinkVerifyError, MagicLinkVerifyPageConfig, } from './components/MagicLinkVerifyPage';

package/dist/fe/index.js

@@ -15,6 +15,7 @@ export { ComponentCanvas, ComponentSidebar, createDefaultRegistry, DesignSystemP
 export { DeviceCard, DevicesHeader, DevicesPage, useDevicesStore } from './components/DevicesPage';
 export { ForgotPasswordPage, useForgotPasswordStore } from './components/ForgotPasswordPage';
 export { FormBuilder, FormField, formBuilderTheme, useFormBuilder } from './components/FormBuilder';
+export { extendIntegrationsTheme, IntegrationsPage, integrationsPageTheme, useIntegrationsStore } from './components/IntegrationsPage';
 export { LoginPage, useLoginStore } from './components/LoginPage';
 export { MagicLinkVerifyPage, magicLinkVerifyPageTheme, useMagicLinkVerifyStore } from './components/MagicLinkVerifyPage';
 export { extendNotificationCenterTheme, NotificationBell, NotificationCenter, notificationCenterTheme, useNotificationCenterStore } from './components/NotificationCenter';