@portalduct/react-sdk-factorcloud-legacy 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 PortalDuct
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,271 @@
+# @portalduct/react-sdk-factorcloud-legacy
+
+React SDK for connecting FactorCloud debtors to carrier portals and syncing invoice data through an embedded modal workflow.
+
+> **Auto-managed credentials**
+>
+> The SDK bootstraps its runtime configuration from the `check-customer-status` webhook. Supply your FactorCloud factor ID and the PortalDuct webhook bearer token and the SDK will fetch the latest FactorCloud and PortalDuct API tokens, API base URLs, and PortalDuct customer UUID for you.
+
+## Installation
+
+```bash
+npm install @portalduct/react-sdk-factorcloud-legacy
+```
+
+**Required peer dependencies** (install if you don't have them):
+
+```bash
+npm install react react-dom @tanstack/react-query react-hook-form @hookform/resolvers lucide-react
+```
+
+## Quick Start
+
+### 1. Drop in the prebuilt Sync banner (no manual CSS import needed)
+
+The bundle ships with its own stylesheet, so you can simply import the banner component and start collecting connections. Only two required inputs are needed up front: the PortalDuct webhook bearer token (to call the Supabase webhooks) and your FactorCloud factor ID. Everything else is populated automatically after the first customer status check.
+
+```tsx
+import { SyncBanner, type SDKConfig } from '@portalduct/react-sdk-factorcloud-legacy';
+
+const baseConfig = {
+  portalduct: {
+    webhook_bearer_token: 'fc_webhook_token',
+    // Optional overrides if you are not using the default Supabase functions
+    sync_webhook_url: 'https://example.supabase.co/functions/v1/webhook-sync-connection',
+    verify_webhook_url: 'https://example.supabase.co/functions/v1/webhook-verify-connection',
+    environment: 'sandbox', // Optional: force the environment sent to Supabase
+  },
+  factorcloud: {
+    factorId: 'your_factor_id',
+    client_id: 'optional_client_id', // Optional: pre-select a client
+  },
+} satisfies Partial<SDKConfig>;
+
+function MyApp() {
+  return (
+    <SyncBanner
+      config={baseConfig as SDKConfig} // Remaining fields are hydrated by the SDK
+      onSyncComplete={() => console.log('Sync complete')}
+      onSyncError={(error) => console.error('Sync failed', error)}
+    />
+  );
+}
+```
+
+> **TypeScript tip:** When you only provide the minimal fields above, cast the object to `SDKConfig` at the callsite (as shown). The SDK fills in the missing properties after the status check resolves.
+
+### 2. Prefer manual control? Wrap your app with `QueryClientProvider`
+
+If you need custom layout control, render `SyncWorkflow` directly. The banner example above auto-creates a React Query client, but for full control create your own instance and wrap your app:
+
+```tsx
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { SyncWorkflow, type SDKConfig } from '@portalduct/react-sdk-factorcloud-legacy';
+
+const baseConfig = {
+  portalduct: { webhook_bearer_token: 'fc_webhook_token' },
+  factorcloud: { factorId: 'your_factor_id' },
+} satisfies Partial<SDKConfig>;
+
+const queryClient = new QueryClient();
+
+function App() {
+  return (
+    <QueryClientProvider client={queryClient}>
+      {/* Your app content */}
+      <SyncWorkflow
+        config={baseConfig as SDKConfig}
+        trigger={<button>Sync Invoices</button>}
+      />
+    </QueryClientProvider>
+  );
+}
+```
+
+That's it! Clicking the "Sync Invoices" button opens a modal workflow that handles:
+- Client selection (if no `client_id` provided)
+- Debtor selection
+- Portal connection setup
+- Credential management (tokens are refreshed automatically)
+- Invoice synchronization
+
+## Configuration
+
+### Minimal configuration inputs
+
+Only two fields are required at initialization time:
+
+| Field | Required? | Description |
+|-------|-----------|-------------|
+| `portalduct.webhook_bearer_token` | ✅ | Authenticates requests to the Supabase webhooks (`check-customer-status`, `webhook-sync-connection`, `webhook-verify-connection`). |
+| `factorcloud.factorId` | ✅ | Identifies which FactorCloud account should be synced. |
+
+Optional overrides you can provide:
+
+| Field | When to set it |
+|-------|----------------|
+| `portalduct.sync_webhook_url` / `portalduct.verify_webhook_url` | Override the default Supabase function URLs. |
+| `portalduct.environment` | Force a specific environment string to be sent to the webhook payload. The SDK auto-detects `sandbox` vs `production`, so most integrations can omit this. |
+| `factorcloud.client_id` | Skip the client-selection step during syncing. |
+
+Everything else—PortalDuct API bearer token, FactorCloud API bearer token, API base URLs, and the PortalDuct customer UUID—is hydrated automatically from the customer status response.
+
+### Runtime configuration shape
+
+Internally the SDK works with a fully populated configuration object:
+
+```ts
+import type { SDKConfig } from '@portalduct/react-sdk-factorcloud-legacy';
+
+// After the first status check completes the SDK produces an object like this:
+const resolvedConfig: SDKConfig = {
+  portalduct: {
+    bearer_token: 'pd_token',
+    env_url: 'https://sandbox.portalduct.com',
+    customer_id: '896ec608-373f-4fde-82e5-00b1f427dba5',
+    webhook_bearer_token: 'fc_webhook_token',
+    environment: 'sandbox',
+    sync_webhook_url: 'https://example.supabase.co/functions/v1/webhook-sync-connection',
+    verify_webhook_url: 'https://example.supabase.co/functions/v1/webhook-verify-connection',
+  },
+  factorcloud: {
+    bearer_token: 'fc_token',
+    factorId: 'your_factor_id',
+    env_url: 'https://api.int.factorcloud.com',
+    client_id: 'optional_client_id',
+  },
+};
+```
+
+Use the `useCustomerStatus` hook to observe and reuse the merged configuration:
+
+```tsx
+import { useCustomerStatus, type SDKConfig } from '@portalduct/react-sdk-factorcloud-legacy';
+
+const baseConfig = {
+  portalduct: { webhook_bearer_token: 'fc_webhook_token' },
+  factorcloud: { factorId: 'your_factor_id' },
+} satisfies Partial<SDKConfig>;
+
+function DebugConfig() {
+  const { resolvedConfig, loading } = useCustomerStatus(baseConfig as SDKConfig);
+
+  if (loading || !resolvedConfig) return <p>Loading…</p>;
+  return <pre>{JSON.stringify(resolvedConfig, null, 2)}</pre>;
+}
+```
+
+### Standalone Modal Components
+
+Import individual modals for custom workflows:
+
+```tsx
+import { useState } from 'react';
+import {
+  ConfigModal,
+  ConnectDebtorModal,
+  RequestPortalModal,
+  UpdateCredentialsModal,
+  SyncProgressModal,
+  ClientSelectionModal,
+  type SDKConfig,
+} from '@portalduct/react-sdk-factorcloud-legacy';
+
+function CustomWorkflow() {
+  const [open, setOpen] = useState(false);
+  const [config, setConfig] = useState<Partial<SDKConfig>>({
+    portalduct: { webhook_bearer_token: 'fc_webhook_token' },
+    factorcloud: { factorId: 'your_factor_id' },
+  });
+
+  return (
+    <ConfigModal
+      open={open}
+      onOpenChange={setOpen}
+      onSave={(next) => setConfig(next)}
+      currentConfig={config as SDKConfig}
+    />
+  );
+}
+```
+
+### Direct API Access
+
+Need to orchestrate data yourself? Pull the resolved config from `useCustomerStatus` first, then hand it to the lower-level API clients:
+
+```tsx
+import { useCustomerStatus, type SDKConfig } from '@portalduct/react-sdk-factorcloud-legacy';
+import {
+  PortalDuctAPI,
+  FactorCloudAPI,
+  ConnectionSyncAPI,
+} from '@portalduct/react-sdk-factorcloud-legacy';
+
+const baseConfig = {
+  portalduct: { webhook_bearer_token: 'fc_webhook_token' },
+  factorcloud: { factorId: 'your_factor_id' },
+} satisfies Partial<SDKConfig>;
+
+function CustomDataFlow() {
+  const { resolvedConfig } = useCustomerStatus(baseConfig as SDKConfig);
+
+  if (!resolvedConfig) {
+    return <p>Loading credentials…</p>;
+  }
+
+  const portalductApi = new PortalDuctAPI(
+    resolvedConfig.portalduct.env_url,
+    resolvedConfig.portalduct.bearer_token,
+  );
+
+  const factorcloudApi = new FactorCloudAPI(
+    resolvedConfig.factorcloud.env_url,
+    resolvedConfig.factorcloud.factorId,
+    resolvedConfig.factorcloud.bearer_token,
+  );
+
+  const connectionSync = new ConnectionSyncAPI({
+    webhookToken: resolvedConfig.portalduct.webhook_bearer_token,
+    customerId: resolvedConfig.portalduct.customer_id,
+    environment: resolvedConfig.portalduct.environment,
+    webhookUrl: resolvedConfig.portalduct.sync_webhook_url,
+    verifyWebhookUrl: resolvedConfig.portalduct.verify_webhook_url,
+    portalductBaseUrl: resolvedConfig.portalduct.env_url,
+  });
+
+  // ...custom logic using the clients above
+}
+```
+
+### Data Orchestration Service
+
+For complex data synchronization workflows you can instantiate the orchestration service once the config has been resolved:
+
+```tsx
+import { useEffect } from 'react';
+import { useCustomerStatus, DataOrchestrationService, type SDKConfig } from '@portalduct/react-sdk-factorcloud-legacy';
+
+const baseConfig = {
+  portalduct: { webhook_bearer_token: 'fc_webhook_token' },
+  factorcloud: { factorId: 'your_factor_id' },
+} satisfies Partial<SDKConfig>;
+
+function SyncAllDebtors() {
+  const { resolvedConfig } = useCustomerStatus(baseConfig as SDKConfig);
+
+  useEffect(() => {
+    if (!resolvedConfig) return;
+
+    const orchestration = new DataOrchestrationService(resolvedConfig);
+    orchestration.getFactorCloudClients().then(console.log);
+  }, [resolvedConfig]);
+
+  return null;
+}
+```
+
+## Security
+
+⚠️ **Never expose API tokens in client-side code in production!**
+
+Even though the SDK auto-fetches credentials, the webhook you call still needs to run on a trusted backend (the provided Supabase functions or your own infrastructure). Store the webhook bearer token securely (environment variables, secret manager, etc.) and never hard-code it in publicly distributed builds.

package/dist/api/connectionSync.d.ts

@@ -0,0 +1,51 @@
+import { CustomerStatusPayload } from '../types/config';
+import { ResyncResponse } from '../types/portalduct';
+
+type Environment = "sandbox" | "production" | string;
+interface ConnectionSyncOptions {
+    webhookToken?: string;
+    customerId?: string;
+    /**
+     * Optional override for the sync webhook URL. Defaults to the Supabase function.
+     */
+    webhookUrl?: string;
+    /**
+     * Optional override for the verification webhook URL. Defaults to the Supabase function.
+     */
+    verifyWebhookUrl?: string;
+    /**
+     * Explicit environment identifier to send to the webhook.
+     */
+    environment?: Environment;
+    /**
+     * PortalDuct environment URL, used for automatic environment detection when
+     * an explicit environment value isn't provided.
+     */
+    portalductBaseUrl?: string;
+    /**
+     * Optional override for the customer status webhook URL. Defaults to the Supabase function.
+     */
+    customerStatusUrl?: string;
+}
+export declare class ConnectionSyncAPI {
+    private syncWebhookUrl;
+    private verifyWebhookUrl;
+    private webhookToken?;
+    private customerId?;
+    private environment;
+    private customerStatusUrl;
+    constructor({ webhookToken, customerId, webhookUrl, verifyWebhookUrl, environment, portalductBaseUrl, customerStatusUrl, }: ConnectionSyncOptions);
+    setWebhookToken(token: string): void;
+    setCustomerId(customerId: string): void;
+    setEnvironment(environment: Environment): void;
+    setWebhookUrl(webhookUrl: string): void;
+    setVerifyWebhookUrl(webhookUrl: string): void;
+    setCustomerStatusUrl(webhookUrl: string): void;
+    triggerConnectionSync(connectionId: string): Promise<ResyncResponse>;
+    triggerConnectionVerification(connectionId: string): Promise<ResyncResponse>;
+    private callWebhook;
+    private deriveEnvironmentFromBaseUrl;
+    fetchCustomerStatus(factorId: string): Promise<CustomerStatusPayload>;
+    isCustomerActive(factorId: string): Promise<boolean>;
+}
+export {};

package/dist/api/factorcloud.d.ts

@@ -0,0 +1,13 @@
+import { FactorCloudClient, FactorCloudClientDetail, FactorCloudDebtor } from '../types/factorcloud';
+
+export declare class FactorCloudAPI {
+    private baseUrl;
+    private factorId;
+    private token;
+    constructor(baseUrl: string, factorId: string, bearerToken: string);
+    getClients(limit?: number, page?: number): Promise<FactorCloudClient[]>;
+    getClientById(clientId: string): Promise<FactorCloudClientDetail>;
+    getDebtors(clientId: string, limit?: number, page?: number): Promise<FactorCloudDebtor[]>;
+    setToken(token: string): void;
+    getToken(): string;
+}

package/dist/api/portalduct.d.ts

@@ -0,0 +1,33 @@
+import { PortalDuctCompany, PortalDuctConnection, CreateCompanyRequest, CreateConnectionRequest, UpdateConnectionRequest, PortalMapping, CreatePortalMappingRequest } from '../types/portalduct';
+
+export declare class PortalDuctAPIError extends Error {
+    status: number;
+    code?: string;
+    type?: string;
+    requestId?: string;
+    constructor({ message, status, code, type, requestId, }: {
+        message: string;
+        status: number;
+        code?: string;
+        type?: string;
+        requestId?: string;
+    });
+}
+export declare class PortalDuctAPI {
+    private baseUrl;
+    private token;
+    constructor(baseUrl: string, bearerToken: string);
+    private buildError;
+    getCompanies(customerId: string): Promise<PortalDuctCompany[]>;
+    createCompany(request: CreateCompanyRequest): Promise<PortalDuctCompany>;
+    getConnections(companyId: string): Promise<PortalDuctConnection[]>;
+    createConnection(request: CreateConnectionRequest): Promise<PortalDuctConnection>;
+    updateConnection(connectionId: string, request: UpdateConnectionRequest): Promise<PortalDuctConnection>;
+    activateConnection(connectionId: string): Promise<PortalDuctConnection>;
+    deactivateConnection(connectionId: string): Promise<PortalDuctConnection>;
+    private updateActivationStatus;
+    setToken(token: string): void;
+    getToken(): string;
+    getPortalMappings(): Promise<PortalMapping[]>;
+    createPortalMapping(request: CreatePortalMappingRequest): Promise<PortalMapping>;
+}

package/dist/components/ClientSelectionModal.d.ts

@@ -0,0 +1,10 @@
+import { FactorCloudClient } from '../types/factorcloud';
+
+interface ClientSelectionModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    clients: FactorCloudClient[];
+    onSelect: (client: FactorCloudClient) => void;
+}
+export declare function ClientSelectionModal({ open, onOpenChange, clients, onSelect, }: ClientSelectionModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ConfigModal.d.ts

@@ -0,0 +1,10 @@
+import { SDKConfig } from '../types/config';
+
+interface ConfigModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSave: (config: SDKConfig) => void;
+    currentConfig?: Partial<SDKConfig>;
+}
+export declare const ConfigModal: ({ open, onOpenChange, onSave, currentConfig, }: ConfigModalProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ConnectDebtorModal.d.ts

@@ -0,0 +1,16 @@
+import { MergedDebtor } from '../types/merged';
+import { PortalMapping } from '../types/portalduct';
+
+interface ConnectDebtorModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    debtor: MergedDebtor | null;
+    availablePortals: PortalMapping[];
+    loadingPortals?: boolean;
+    loading?: boolean;
+    isChangingPortal?: boolean;
+    onConnect: (portalId: string, username: string, password: string) => void;
+    onRequestNewPortal: () => void;
+}
+export declare function ConnectDebtorModal({ open, onOpenChange, debtor, availablePortals, loadingPortals, loading, isChangingPortal, onConnect, onRequestNewPortal }: ConnectDebtorModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/InterestSyncModal.d.ts

@@ -0,0 +1,5 @@
+export interface InterestSyncModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+export declare function InterestSyncModal({ open, onOpenChange }: InterestSyncModalProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/PortalIntegration.d.ts

@@ -0,0 +1,8 @@
+import { SDKConfig } from '../types/config';
+
+interface PortalIntegrationProps {
+    config: SDKConfig;
+    onTokenExpired?: (service: 'factorcloud' | 'portalduct') => void;
+}
+export declare const PortalIntegration: ({ config, onTokenExpired }: PortalIntegrationProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/RequestPortalModal.d.ts

@@ -0,0 +1,8 @@
+interface RequestPortalModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    loading?: boolean;
+    onSubmit: (name: string, host: string) => void;
+}
+export declare function RequestPortalModal({ open, onOpenChange, loading, onSubmit }: RequestPortalModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/SyncBanner.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import { QueryClient } from '@tanstack/react-query';
+import { SyncWorkflowProps } from './SyncWorkflow';
+
+type SyncWorkflowPropKeys = "config" | "onTokenExpired" | "onSyncComplete" | "onSyncError" | "autoStart";
+export interface SyncBannerProps extends Pick<SyncWorkflowProps, SyncWorkflowPropKeys> {
+    queryClient?: QueryClient;
+    title?: ReactNode;
+    badge?: ReactNode;
+    ctaLabel?: ReactNode;
+    icon?: ReactNode;
+    variant?: "full" | "compact";
+    theme?: "light" | "dark" | "auto";
+}
+export declare const SyncBanner: ({ config, queryClient, variant, theme, title, badge, ctaLabel, icon, onTokenExpired, onSyncComplete, onSyncError, autoStart, }: SyncBannerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/SyncProgressModal.d.ts

@@ -0,0 +1,31 @@
+import { FactorCloudClient } from '../types/factorcloud';
+import { MergedDebtor } from '../types/merged';
+
+export type SyncStep = "idle" | "checking-config" | "authenticating" | "loading-clients" | "selecting-client" | "selecting-debtor" | "loading-data" | "review" | "complete" | "error";
+interface SyncProgressModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    currentStep: SyncStep;
+    error?: string;
+    clients?: FactorCloudClient[];
+    debtors?: MergedDebtor[];
+    selectedDebtor?: MergedDebtor | null;
+    selectedClient?: FactorCloudClient | null;
+    onSelectClient?: (client: FactorCloudClient) => void;
+    onSelectDebtor?: (debtor: MergedDebtor) => void;
+    onConnectDebtor?: (debtor: MergedDebtor) => void;
+    onEditCredentials?: (debtor: MergedDebtor) => void;
+    onChangePortal?: (debtor: MergedDebtor) => void;
+    onToggleActivation?: (debtor: MergedDebtor) => void;
+    onSyncDebtor?: (debtor: MergedDebtor) => void;
+    onVerifyDebtor?: (debtor: MergedDebtor) => void;
+    togglingDebtorId?: string | null;
+    syncingDebtorId?: string | null;
+    verifyingDebtorId?: string | null;
+    allowBackToClientSelection?: boolean;
+    onBackToClientSelection?: () => void;
+    activeTab?: MergedDebtor["status"];
+    onActiveTabChange?: (tab: MergedDebtor["status"]) => void;
+}
+export declare function SyncProgressModal({ open, onOpenChange, currentStep, error, clients, debtors, selectedDebtor, selectedClient, onSelectClient, onSelectDebtor, onConnectDebtor, onEditCredentials, onChangePortal, onToggleActivation, onSyncDebtor, onVerifyDebtor, togglingDebtorId, syncingDebtorId, verifyingDebtorId, allowBackToClientSelection, onBackToClientSelection, activeTab, onActiveTabChange, }: SyncProgressModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/SyncWorkflow.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { SDKConfig } from '../types/config';
+import { MergedDebtor } from '../types/merged';
+import { CustomerStatusState } from '../hooks/use-customer-status';
+
+export interface SyncWorkflowProps {
+    config: SDKConfig;
+    onTokenExpired?: (service: 'factorcloud' | 'portalduct') => void;
+    trigger?: ReactNode;
+    onSyncComplete?: (debtors: MergedDebtor[]) => void;
+    onSyncError?: (error: Error) => void;
+    autoStart?: boolean;
+    customerStatus?: CustomerStatusState;
+}
+export declare const SyncWorkflow: ({ config, onTokenExpired, trigger, onSyncComplete, onSyncError, autoStart, customerStatus, }: SyncWorkflowProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/UpdateCredentialsModal.d.ts

@@ -0,0 +1,11 @@
+import { MergedDebtor } from '../types/merged';
+
+interface UpdateCredentialsModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    debtor: MergedDebtor | null;
+    onUpdate: (username: string, password: string) => void;
+    loading?: boolean;
+}
+export declare function UpdateCredentialsModal({ open, onOpenChange, debtor, onUpdate, loading, }: UpdateCredentialsModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/accordion.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as AccordionPrimitive from "@radix-ui/react-accordion";
+declare const Accordion: React.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionItem: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionTrigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AccordionContent: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

package/dist/components/ui/alert-dialog.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog";
+declare const AlertDialog: React.FC<AlertDialogPrimitive.AlertDialogProps>;
+declare const AlertDialogTrigger: React.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogPortal: React.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+declare const AlertDialogOverlay: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogContent: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogTitle: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const AlertDialogDescription: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDialogAction: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const AlertDialogCancel: React.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

package/dist/components/ui/alert.d.ts

@@ -0,0 +1,8 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const Alert: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: {
+    variant?: "default" | "destructive";
+} & import('class-variance-authority/types').ClassProp) => string> & React.RefAttributes<HTMLDivElement>>;
+declare const AlertTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const AlertDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export { Alert, AlertTitle, AlertDescription };

package/dist/components/ui/aspect-ratio.d.ts

@@ -0,0 +1,3 @@
+import * as AspectRatioPrimitive from "@radix-ui/react-aspect-ratio";
+declare const AspectRatio: import('react').ForwardRefExoticComponent<AspectRatioPrimitive.AspectRatioProps & import('react').RefAttributes<HTMLDivElement>>;
+export { AspectRatio };

package/dist/components/ui/avatar.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import * as AvatarPrimitive from "@radix-ui/react-avatar";
+declare const Avatar: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const AvatarImage: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React.RefAttributes<HTMLImageElement>, "ref"> & React.RefAttributes<HTMLImageElement>>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Avatar, AvatarImage, AvatarFallback };

package/dist/components/ui/badge.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const badgeVariants: (props?: {
+    variant?: "default" | "destructive" | "outline" | "secondary";
+} & import('class-variance-authority/types').ClassProp) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

package/dist/components/ui/breadcrumb.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+declare const Breadcrumb: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    separator?: React.ReactNode;
+} & React.RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const BreadcrumbLink: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbPage: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, };

package/dist/components/ui/button.d.ts

@@ -0,0 +1,11 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const buttonVariants: (props?: {
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | "factorcloud" | "success" | "tab";
+    size?: "default" | "tab" | "sm" | "lg" | "icon";
+} & import('class-variance-authority/types').ClassProp) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

package/dist/components/ui/calendar.d.ts

@@ -0,0 +1,8 @@
+import { DayPicker } from 'react-day-picker';
+import * as React from "react";
+export type CalendarProps = React.ComponentProps<typeof DayPicker>;
+declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+export { Calendar };