@wacht/jsx 0.0.1-alpha.5 → 0.0.1-alpha.7

package/dist/index.d.ts

@@ -1,5 +1,1311 @@
-export * from './context';
-export * from './hooks';
-export * from './components';
-export * from './types';
-export { isExternalUrl, isSafeUrl } from './utils/navigation';
+import { ApiResult } from '@wacht/types';
+import { ButtonHTMLAttributes } from 'react';
+import { Client } from '@wacht/types';
+import { CSSProperties } from 'react';
+import { CurrentUser } from '@wacht/types';
+import { default as default_2 } from 'react';
+import { Deployment } from '@wacht/types';
+import { DeploymentContextType as DeploymentContextType_2 } from '..';
+import { DetailedHTMLProps } from 'react';
+import { ErrorInterface } from '@wacht/types';
+import { FastOmit } from 'styled-components';
+import { FC } from 'react';
+import { FormHTMLAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { HTMLAttributes } from 'react';
+import { InputHTMLAttributes } from 'react';
+import { IStyledComponentBase } from 'styled-components/dist/types';
+import { JSX } from 'react/jsx-runtime';
+import { KeyedMutator } from 'swr';
+import { LabelHTMLAttributes } from 'react';
+import { NewDomain } from '@wacht/types';
+import { NewOrgnization } from '@wacht/types';
+import { Organization } from '@wacht/types';
+import { OrganizationDomain } from '@wacht/types';
+import { OrganizationInvitation } from '@wacht/types';
+import { OrganizationInvitationPayload } from '@wacht/types';
+import { OrganizationMembership } from '@wacht/types';
+import { OrganizationMembershipWithOrganization } from '@wacht/types';
+import { OrganizationRole } from '@wacht/types';
+import { OrganizationUpdate } from '@wacht/types';
+import { ProfileCompletionData } from '@wacht/types';
+import { ProfileCompletionProps } from '@wacht/types';
+import { ReactNode } from 'react';
+import { RefAttributes } from 'react';
+import { RoleCreate } from '@wacht/types';
+import { SecondFactorPolicy } from '@wacht/types';
+import { Session } from '@wacht/types';
+import { SignIn as SignIn_2 } from '@wacht/types';
+import { SigninAttempt } from '@wacht/types';
+import { SignupAttempt } from '@wacht/types';
+import { SignUpParams } from '@wacht/types';
+import { SocialConnection } from '@wacht/types';
+import { Substitute } from 'styled-components/dist/types';
+import { UserAuthenticator } from '@wacht/types';
+import { UserEmailAddress } from '@wacht/types';
+import { UserPhoneNumber } from '@wacht/types';
+import { Workspace } from '@wacht/types';
+import { WorkspaceMembership } from '@wacht/types';
+import { WorkspaceRole } from '@wacht/types';
+import { WorkspaceWithOrganization } from '@wacht/types';
+
+export declare interface AcceptInvitationResponse {
+    organization?: {
+        id: string;
+        name: string;
+    };
+    workspace?: {
+        id: string;
+        name: string;
+    };
+    signin_id?: string;
+    already_member?: boolean;
+    message?: string;
+    requires_signin?: boolean;
+    invited_email?: string;
+    error_code?: string;
+}
+
+export declare function AcceptInvite({ token: propToken, onSuccess, onError, }: AcceptInviteProps): JSX.Element | null;
+
+declare interface AcceptInviteProps {
+    token?: string;
+    onSuccess?: (organizationId?: string, workspaceId?: string) => void;
+    onError?: (error: string) => void;
+}
+
+export declare function AgentConversation({ showBackButton, onBack, }: AgentConversationProps): JSX.Element;
+
+declare interface AgentConversationContextValue {
+    agentName: string;
+    token: string;
+    platformAdapter?: PlatformAdapter_2;
+    sessions: ConversationSession[];
+    selectedSession: ConversationSession | null;
+    loadingSessions: boolean;
+    sessionError: Error | null;
+    selectSession: (session: ConversationSession | null) => void;
+    createSession: (title?: string) => Promise<ConversationSession>;
+    deleteSession: (sessionId: string) => Promise<void>;
+    refreshSessions: () => Promise<void>;
+    showHistory: boolean;
+    setShowHistory: (show: boolean) => void;
+    onSessionCreated?: (session: ConversationSession) => void;
+    onSessionDeleted?: (sessionId: string) => void;
+    onError?: (error: string) => void;
+}
+
+export declare function AgentConversationHistory({ showBackButton, }: AgentConversationHistoryProps): JSX.Element;
+
+declare interface AgentConversationHistoryProps {
+    showBackButton?: boolean;
+}
+
+export declare function AgentConversationHub(): JSX.Element;
+
+declare interface AgentConversationProps {
+    showBackButton?: boolean;
+    onBack?: () => void;
+}
+
+export declare function AgentConversationProvider({ children, agentName, token, platformAdapter, defaultSessionId, onSessionCreated, onSessionDeleted, onError, }: AgentConversationProviderProps): JSX.Element;
+
+declare interface AgentConversationProviderProps {
+    children: ReactNode;
+    agentName: string;
+    token: string;
+    platformAdapter?: PlatformAdapter_2;
+    defaultSessionId?: string;
+    onSessionCreated?: (session: ConversationSession) => void;
+    onSessionDeleted?: (sessionId: string) => void;
+    onError?: (error: string) => void;
+}
+
+export declare function AuthFormImage(): JSX.Element;
+
+export declare interface BulkUpdateResponse {
+    affected: number;
+}
+
+export declare interface ChannelCounts {
+    user: number;
+    organization: number;
+    workspace: number;
+    current: number;
+    total: number;
+}
+
+export declare function ChannelSelector({ selectedChannels, channelCounts, onChannelsChange }: ChannelSelectorProps): JSX.Element;
+
+declare interface ChannelSelectorProps {
+    selectedChannels: string[];
+    channelCounts?: ChannelCounts;
+    onChannelsChange: (channels: string[]) => void;
+}
+
+export declare function clearTokenCache(): void;
+
+declare const CONNECTION_STATES: {
+    readonly DISCONNECTED: "disconnected";
+    readonly CONNECTING: "connecting";
+    readonly CONNECTED: "connected";
+    readonly ERROR: "error";
+};
+
+export declare interface ConversationMessage {
+    id: string | number;
+    role: "user" | "assistant" | "system";
+    content: string;
+    timestamp: Date;
+    isStreaming?: boolean;
+    images?: ImageData_2[];
+    metadata?: {
+        type?: "user_input_request" | "log";
+        userInputRequest?: UserInputRequest;
+        messageType?: string;
+    };
+}
+
+export declare interface ConversationSession {
+    id: string;
+    title: string;
+    status: 'idle' | 'running' | 'waiting_for_input' | 'interrupted' | 'completed' | 'failed';
+    last_activity_at: string;
+    context_group?: string;
+    created_at: string;
+}
+
+export declare const CreateOrganizationForm: React.FC<CreateOrganizationFormProps>;
+
+declare interface CreateOrganizationFormProps {
+    onSuccess?: () => void;
+    onCancel?: () => void;
+}
+
+export declare interface CreateSessionRequest {
+    title: string;
+    system_instructions?: string;
+}
+
+declare type CreateSignInStrategyResult = {
+    (strategy: "username"): SignInPlainUsername;
+    (strategy: "email"): SignInPlainEmail;
+    (strategy: "phone"): SignInPhone;
+    (strategy: "email_otp"): SignInEmailOTP;
+    (strategy: "magic_link"): SignInMagicLink;
+    (strategy: "oauth"): SignInOauth;
+    (strategy: "generic"): SignInGeneric;
+};
+
+export declare const CreateWorkspaceDialog: default_2.FC<CreateWorkspaceDialogProps>;
+
+declare interface CreateWorkspaceDialogProps {
+    isOpen: boolean;
+    onClose?: () => void;
+    onCreated?: () => void;
+    organizationId: string;
+}
+
+export declare const CreateWorkspaceForm: default_2.FC<CreateWorkspaceFormProps>;
+
+declare interface CreateWorkspaceFormProps {
+    organizationId: string;
+    onSuccess?: () => void;
+    onCancel?: () => void;
+    onCreateOrganization?: () => void;
+}
+
+export declare interface DeploymentContextType {
+    loading: boolean;
+    deployment: Deployment | null;
+    adapter: PlatformAdapter;
+}
+
+export declare const DeploymentInitialized: React.FC<DeploymentInstanceProps>;
+
+export declare const DeploymentInitializing: React.FC<DeploymentInstanceProps>;
+
+declare interface DeploymentInstanceProps {
+    children: ReactNode;
+}
+
+export declare interface DeploymentInvitationData {
+    valid: boolean;
+    first_name?: string;
+    last_name?: string;
+    email?: string;
+    message?: string;
+    error_code?: string;
+}
+
+export declare function DeploymentProvider({ children, publicKey, adapter, }: DeploymentProviderProps): JSX.Element;
+
+declare interface DeploymentProviderProps {
+    children: ReactNode;
+    publicKey: string;
+    adapter: PlatformAdapter;
+}
+
+export declare const Dialog: FC<DialogProps> & {
+    Overlay: FC<{
+        children?: ReactNode;
+    }>;
+    Content: FC<DialogContentProps>;
+    Header: FC<DialogHeaderProps>;
+    Body: FC<DialogBodyProps>;
+    Footer: FC<DialogFooterProps>;
+};
+
+declare interface DialogBodyProps {
+    children: ReactNode;
+    style?: React.CSSProperties;
+}
+
+declare interface DialogContentProps {
+    children: ReactNode;
+    style?: React.CSSProperties;
+}
+
+declare interface DialogFooterProps {
+    children: ReactNode;
+}
+
+declare interface DialogHeaderProps {
+    children?: ReactNode;
+    showCloseButton?: boolean;
+}
+
+declare interface DialogProps {
+    isOpen: boolean;
+    onClose?: () => void;
+    children: ReactNode;
+}
+
+export declare const DialogTrigger: FC<DialogTriggerProps>;
+
+declare interface DialogTriggerProps {
+    trigger: (props: {
+        onClick: () => void;
+    }) => ReactNode;
+    renderDialog: (props: {
+        isOpen: boolean;
+        onClose: () => void;
+    }) => ReactNode;
+}
+
+export declare const Dropdown: ({ children, open, openChange, style, }: DropdownProps) => JSX.Element;
+
+export declare const DropdownDivider: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+
+export declare const DropdownItem: IStyledComponentBase<"web", Substitute<DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
+$destructive?: boolean;
+}>> & string;
+
+export declare const DropdownItems: ({ children, style, }: {
+    children: ReactNode;
+    style?: React.CSSProperties;
+}) => JSX.Element | null;
+
+declare interface DropdownProps {
+    children: ReactNode;
+    open?: boolean;
+    openChange?: (open: boolean) => void;
+    style?: CSSProperties;
+}
+
+export declare const DropdownTrigger: ({ children }: {
+    children: ReactNode;
+}) => JSX.Element;
+
+declare type EmailOTPSignInParams = {
+    email: string;
+};
+
+declare type EmailOTPVerificationParams = {
+    strategy: "email_otp";
+    redirectUri?: string;
+};
+
+declare type EmailSignInParams = {
+    email: string;
+    password: string;
+};
+
+export declare function fetchChannelCounts(client: Client): Promise<ChannelCounts>;
+
+export declare const Form: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, never>> & string;
+
+export declare const FormGroup: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+
+/**
+ * Unified execution status mapping between frontend and backend
+ */
+declare const FRONTEND_STATUS: {
+    readonly IDLE: "idle";
+    readonly STARTING: "starting";
+    readonly RUNNING: "running";
+    readonly WAITING_FOR_INPUT: "waiting_for_input";
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+};
+
+declare type FrontendStatus = typeof FRONTEND_STATUS[keyof typeof FRONTEND_STATUS];
+
+declare type GenericSignInParams = {
+    email?: string;
+    username?: string;
+    password?: string;
+    phone?: string;
+    strategy?: string;
+};
+
+export declare function hasIncompleteProfile(session: Session): boolean;
+
+declare interface ImageData_2 {
+    mime_type: string;
+    data?: string;
+    url?: string;
+}
+
+declare type InitSSOResponseType = {
+    oauth_url: string;
+    session: Session;
+};
+
+export declare const Input: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, never>> & string;
+
+export declare const isExternalUrl: (url: string) => boolean;
+
+export declare const isSafeUrl: (url: string) => boolean;
+
+export declare const Label: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, never>> & string;
+
+export declare interface ListSessionsOptions {
+    limit?: number;
+    offset?: number;
+    status?: string;
+    search?: string;
+}
+
+export declare interface ListSessionsResponse {
+    data: ConversationSession[];
+    has_more: boolean;
+}
+
+export declare interface MagicLinkParams {
+    token?: string;
+    attempt?: string;
+    redirectUri?: string;
+}
+
+declare type MagicLinkSignInParams = {
+    email: string;
+};
+
+export declare function MagicLinkVerification({ onSuccess, onError, }?: MagicLinkVerificationProps): JSX.Element;
+
+declare type MagicLinkVerificationParams = {
+    strategy: "magic_link";
+    redirectUri?: string;
+};
+
+declare interface MagicLinkVerificationProps {
+    onSuccess?: () => void;
+    onError?: (error: string) => void;
+}
+
+export declare const ManageAccount: () => JSX.Element;
+
+export declare const ManageAccountDialog: FC<ManageAccountDialogProps>;
+
+declare interface ManageAccountDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title?: string;
+    showHeader?: boolean;
+    headerContent?: ReactNode;
+    footerContent?: ReactNode;
+    customContent?: ReactNode;
+    children?: ReactNode;
+    showCloseButton?: boolean;
+}
+
+export declare const ManageOrganization: () => JSX.Element;
+
+export declare const ManageWorkspace: () => JSX.Element | null;
+
+export declare const ManageWorkspaceDialog: FC<ManageWorkspaceDialogProps>;
+
+declare interface ManageWorkspaceDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title?: string;
+    showHeader?: boolean;
+    headerContent?: ReactNode;
+    footerContent?: ReactNode;
+    customContent?: ReactNode;
+    children?: ReactNode;
+    showCloseButton?: boolean;
+}
+
+export declare interface NavigateOptions {
+    replace?: boolean;
+    state?: any;
+}
+
+export declare const NavigateToSignIn: () => null;
+
+export declare const NavigateToSignUp: () => null;
+
+export declare const NavigationLink: default_2.FC<NavigationProps>;
+
+export declare interface NavigationProps {
+    to: string;
+    replace?: boolean;
+    children?: default_2.ReactNode;
+    [key: string]: any;
+}
+
+declare interface Notification_2 {
+    id: string;
+    deployment_id: string;
+    user_id: string;
+    organization_id?: string;
+    workspace_id?: string;
+    title: string;
+    body: string;
+    action_url?: string;
+    action_label?: string;
+    severity: "info" | "success" | "warning" | "error";
+    is_read: boolean;
+    read_at?: string;
+    is_archived: boolean;
+    archived_at?: string;
+    metadata?: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+    expires_at?: string;
+}
+export { Notification_2 as Notification }
+
+export declare function NotificationBell({ className, showBadge, channels, organizationIds, workspaceIds, }: NotificationBellProps): JSX.Element;
+
+declare interface NotificationBellProps {
+    className?: string;
+    showBadge?: boolean;
+    channels?: string[];
+    organizationIds?: number[];
+    workspaceIds?: number[];
+}
+
+export declare function NotificationItem({ notification, onMarkAsRead, onDelete }: NotificationItemProps): JSX.Element;
+
+declare interface NotificationItemProps {
+    notification: Notification_2;
+    onMarkAsRead: (id: string) => void;
+    onDelete: (id: string) => void;
+}
+
+export declare interface NotificationListParams {
+    limit?: number;
+    offset?: number;
+    channels?: string[];
+    organization_ids?: number[];
+    workspace_ids?: number[];
+    is_read?: boolean;
+    is_archived?: boolean;
+    severity?: "info" | "success" | "warning" | "error";
+}
+
+export declare interface NotificationListResponse {
+    notifications: Notification_2[];
+    total: number;
+    unread_count: number;
+    has_more: boolean;
+    channels: string[];
+    unread_counts: ChannelCounts;
+}
+
+export declare interface NotificationMessage {
+    id: number;
+    user_id: number;
+    deployment_id: number;
+    title: string;
+    body: string;
+    severity: string;
+    action_url?: string;
+    action_label?: string;
+    created_at: string;
+}
+
+export declare const NotificationPopover: ForwardRefExoticComponent<NotificationPopoverProps & RefAttributes<HTMLDivElement>>;
+
+declare interface NotificationPopoverProps {
+    position?: {
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    };
+    notifications: Notification_2[];
+    loading: boolean;
+    onMarkAsRead: (id: string) => void;
+    onMarkAllAsRead: () => void;
+    onDelete: (id: string) => void;
+}
+
+export declare enum OAuthProvider {
+    XOauth = "x_oauth",
+    GithubOauth = "github_oauth",
+    GitlabOauth = "gitlab_oauth",
+    GoogleOauth = "google_oauth",
+    FacebookOauth = "facebook_oauth",
+    MicrosoftOauth = "microsoft_oauth",
+    LinkedinOauth = "linkedin_oauth",
+    DiscordOauth = "discord_oauth",
+    AppleOauth = "apple_oauth"
+}
+
+export declare const OrganizationSwitcher: ({ showPersonal, }: OrganizationSwitcherProps) => JSX.Element | null;
+
+declare interface OrganizationSwitcherProps {
+    showPersonal?: boolean;
+}
+
+export declare function OTPInput({ length, onComplete, onResend, error, isSubmitting, }: OTPInputProps): JSX.Element;
+
+declare interface OTPInputProps {
+    length?: number;
+    onComplete: ((code: string) => Promise<void>) | ((code: string) => void);
+    onResend?: () => Promise<void>;
+    error?: string;
+    isSubmitting?: boolean;
+}
+
+export declare const PhoneNumberInput: ({ value, onChange, error, countryCode, setCountryCode, }: {
+    value: string | number | readonly string[] | undefined;
+    onChange: React.ChangeEventHandler<HTMLInputElement>;
+    error: string | undefined;
+    countryCode: string | undefined;
+    setCountryCode: React.Dispatch<React.SetStateAction<string | undefined>>;
+}) => JSX.Element;
+
+declare type PhoneOTPVerificationParams = {
+    strategy: "phone_otp";
+    lastDigits?: string;
+};
+
+declare type PhoneSignInParams = {
+    phone: string;
+};
+
+export declare function PhoneVerification({ onVerify, onBack, loading, }: PhoneVerificationProps): JSX.Element;
+
+declare interface PhoneVerificationProps {
+    onVerify: (lastFourDigits: string) => void;
+    onBack: () => void;
+    loading?: boolean;
+}
+
+export declare interface PlatformAdapter {
+    useNavigate(): ((to: string, options?: NavigateOptions) => void) | null;
+}
+
+declare interface PlatformAdapter_2 {
+    onPlatformEvent?: (eventName: string, eventData: unknown) => void;
+    onPlatformFunction?: (functionName: string, parameters: unknown, executionId: string) => Promise<unknown>;
+}
+
+export declare interface PlatformAdapterContextType {
+    adapter: PlatformAdapter | null;
+}
+
+declare type PrepareVerificationResponse = {
+    otp_sent?: boolean;
+    masked_phone?: string;
+    masked_email?: string;
+    verification_method?: string;
+};
+
+declare type PrepareVerificationResponse_2 = {
+    otp_sent?: boolean;
+    masked_phone?: string;
+    masked_email?: string;
+    verification_method?: string;
+};
+
+export declare function ProfileCompletion({ attempt, onBack, completeProfile, completeVerification, prepareVerification, }: ProfileCompletionProps): JSX.Element;
+
+export { ProfileCompletionData }
+
+export { ProfileCompletionProps }
+
+declare interface ProfileUpdateData {
+    first_name?: string;
+    last_name?: string;
+    username?: string;
+    primary_email_address_id?: string;
+    primary_phone_number_id?: string;
+    second_factor_policy?: SecondFactorPolicy_2;
+    remove_profile_picture?: boolean;
+}
+
+export declare function redirectToProfileCompletion(returnUrl?: string): void;
+
+export declare const RequireActiveTenancy: ({ children, }: RequireActiveTenancyProps) => JSX.Element | null;
+
+declare interface RequireActiveTenancyProps {
+    children: React.ReactNode;
+}
+
+declare type SecondFactorPolicy_2 = "none" | "optional" | "enforced";
+
+export declare const SignedIn: ({ children }: SignedInProps) => JSX.Element | null;
+
+export declare const SignedInAccounts: React.FC<SignedInAccountsProps>;
+
+declare interface SignedInAccountsProps {
+    onAccountSelect?: (signInId: string) => void;
+    showAddAccount?: boolean;
+}
+
+declare interface SignedInProps {
+    children: React.ReactNode;
+}
+
+export declare const SignedOut: ({ children }: SignedOutProps) => JSX.Element | null;
+
+declare interface SignedOutProps {
+    children: React.ReactNode;
+}
+
+declare type SignIn = {
+    createStrategy: CreateSignInStrategyResult;
+    prepareVerification: (params: VerificationParams) => Promise<ApiResult<PrepareVerificationResponse>>;
+    completeVerification: (verificationCode: string) => Promise<Session>;
+    completeProfile: (data: ProfileCompletionData) => Promise<Session>;
+};
+
+declare type SignInEmailOTP = ({ email, }: EmailOTPSignInParams) => Promise<ApiResult<Session>>;
+
+export declare function SignInForm(): JSX.Element;
+
+declare type SignInFunction<T extends SignInStrategy> = {
+    ["username"]: SignInPlainUsername;
+    ["email"]: SignInPlainEmail;
+    ["phone"]: SignInPhone;
+    ["email_otp"]: SignInEmailOTP;
+    ["magic_link"]: SignInMagicLink;
+    ["oauth"]: SignInOauth;
+    ["generic"]: SignInGeneric;
+}[T];
+
+declare type SignInGeneric = ({ email, username, password, phone, strategy, }: GenericSignInParams) => Promise<ApiResult<Session>>;
+
+declare type SignInMagicLink = ({ email, }: MagicLinkSignInParams) => Promise<ApiResult<Session>>;
+
+declare type SignInOauth = ({ provider, redirectUri, }: {
+    provider: OAuthProvider;
+    redirectUri?: string;
+}) => Promise<ApiResult<InitSSOResponseType>>;
+
+declare type SignInPhone = ({ phone, }: PhoneSignInParams) => Promise<ApiResult<Session>>;
+
+declare type SignInPlainEmail = ({ email, password, }: EmailSignInParams) => Promise<ApiResult<Session>>;
+
+declare type SignInPlainUsername = ({ username, password, }: UsernameSignInParams) => Promise<ApiResult<Session>>;
+
+declare type SignInStrategy = "username" | "email" | "phone" | "email_otp" | "magic_link" | "oauth" | "generic";
+
+declare type SignupEmailOTPVerificationParams = {
+    strategy: "email_otp";
+    redirectUri?: string;
+};
+
+export declare function SignUpForm(): JSX.Element;
+
+export declare type SignUpFunction = {
+    create: (params: SignUpParams) => Promise<ApiResult<unknown, ErrorInterface>>;
+    prepareVerification: (params: SignupVerificationParams) => Promise<ApiResult<PrepareVerificationResponse_2>>;
+    completeVerification: (verificationCode: string) => Promise<ApiResult<Session>>;
+    validateDeploymentInvitation: (token: string) => Promise<DeploymentInvitationData>;
+};
+
+declare type SignupPhoneOTPVerificationParams = {
+    strategy: "phone_otp";
+    lastDigits?: string;
+};
+
+declare type SignupVerificationParams = SignupEmailOTPVerificationParams | SignupPhoneOTPVerificationParams;
+
+export declare type SignupVerificationStrategy = "email_otp" | "phone_otp";
+
+export declare const SimpleDialog: FC<SimpleDialogProps>;
+
+declare interface SimpleDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title?: string;
+    children: ReactNode;
+    showCloseButton?: boolean;
+}
+
+export declare const Spinner: ({ size, className }: SpinnerProps) => JSX.Element;
+
+declare interface SpinnerProps {
+    size?: number;
+    className?: string;
+}
+
+export declare function SSOCallback(): JSX.Element;
+
+declare interface SSOCallbackState {
+    loading: boolean;
+    error: Error | null;
+    session: Session | null;
+    redirectUri: string | null;
+    processed: boolean;
+    signinAttempt: SigninAttempt | null;
+}
+
+export declare const Switch: default_2.FC<SwitchProps>;
+
+declare interface SwitchProps {
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+}
+
+export declare interface TwoFactorMethod {
+    id: string;
+    name: string;
+    description: string;
+    icon: React.ReactNode;
+    available: boolean;
+    phoneNumber?: string;
+}
+
+export declare function TwoFactorMethodSelector({ methods, onSelectMethod, onBack, }: TwoFactorMethodSelectorProps): JSX.Element;
+
+declare interface TwoFactorMethodSelectorProps {
+    methods: TwoFactorMethod[];
+    onSelectMethod: (methodId: string) => void;
+    onBack?: () => void;
+}
+
+export declare function TwoFactorVerification({ onBack, attempt, completeVerification, prepareVerification, }: Omit<ProfileCompletionProps, "completeProfile">): JSX.Element;
+
+export declare interface UnreadCountResponse {
+    count: number;
+}
+
+export declare const useActiveOrganization: () => {
+    activeOrganization: null;
+    loading: boolean;
+    error: Error | null;
+    updateOrganization: never;
+    getRoles: never;
+    getMembers: never;
+    getDomains: never;
+    addDomain: never;
+    verifyDomain: never;
+    removeDomain: never;
+    removeRole: never;
+    getInvitations: never;
+    removeMember: never;
+    addMemberRole: never;
+    removeMemberRole: never;
+    inviteMember: never;
+    discardInvitation: never;
+    resendInvitation: never;
+    leave: never;
+    refetch?: undefined;
+} | {
+    activeOrganization: Organization | null;
+    loading: boolean;
+    refetch: () => Promise<void>;
+    getRoles: () => Promise<OrganizationRole[]>;
+    updateOrganization: (update: OrganizationUpdate) => Promise<{
+        data: never;
+        errors: ErrorInterface[];
+    } | never[] | {
+        data: Organization;
+        errors: never;
+    }>;
+    getMembers: () => Promise<OrganizationMembership[]>;
+    getDomains: () => Promise<OrganizationDomain[]>;
+    addDomain: (domain: NewDomain) => Promise<ApiResult<OrganizationDomain> | undefined>;
+    verifyDomain: (domain: OrganizationDomain) => Promise<ApiResult<OrganizationDomain> | undefined>;
+    removeDomain: (domain: OrganizationDomain) => Promise<ApiResult<OrganizationDomain> | undefined>;
+    getInvitations: () => Promise<OrganizationInvitation[]>;
+    removeMember: (member: OrganizationMembership) => Promise<void | never[]>;
+    leave: () => Promise<void>;
+    removeRole: (role: OrganizationRole) => Promise<void>;
+    addMemberRole: (member: OrganizationMembership, role: OrganizationRole) => Promise<OrganizationMembership | undefined>;
+    removeMemberRole: (member: OrganizationMembership, role: OrganizationRole) => Promise<OrganizationMembership | undefined>;
+    inviteMember: (invitationPayload: OrganizationInvitationPayload) => Promise<OrganizationInvitation | undefined>;
+    discardInvitation: (invitation: OrganizationInvitation) => Promise<OrganizationInvitation | undefined>;
+    resendInvitation: (invitation: OrganizationInvitation) => Promise<OrganizationInvitation | undefined>;
+    error: null;
+};
+
+export declare function useActiveTenancy(): {
+    loading: boolean;
+    orgMembership: OrganizationMembershipWithOrganization | null | undefined;
+    workspaceMembership: WorkspaceMembership | null | undefined;
+};
+
+export declare const useActiveWorkspace: () => {
+    activeWorkspace: Workspace | null;
+    loading: boolean;
+    error: any;
+    refetch: () => Promise<void>;
+    leave: () => Promise<void>;
+    updateWorkspace: (data: {
+        name?: string;
+        description?: string;
+        image?: File;
+    }) => Promise<unknown>;
+    deleteWorkspace: () => Promise<unknown>;
+    getMembers: () => Promise<WorkspaceMembership[]>;
+    getRoles: () => Promise<WorkspaceRole[]>;
+    createRole: (name: string, permissions: string[]) => Promise<WorkspaceRole | undefined>;
+    deleteRole: (role: WorkspaceRole) => Promise<unknown>;
+    inviteMember: (email: string, roleId?: string) => Promise<unknown>;
+    removeMember: (memberId: string) => Promise<unknown>;
+    addMemberRole: (membershipId: string, roleId: string) => Promise<unknown>;
+    removeMemberRole: (membershipId: string, roleId: string) => Promise<unknown>;
+};
+
+export declare function useAgentConversation({ contextId, agentName, token, platformAdapter, autoConnect, }: UseAgentConversationProps): {
+    messages: ConversationMessage[];
+    pendingMessage: string | null;
+    pendingImages: ImageData_2[] | null;
+    connectionState: {
+        status: (typeof CONNECTION_STATES)[keyof typeof CONNECTION_STATES];
+    };
+    isConnected: boolean;
+    isExecuting: boolean;
+    executionStatus: FrontendStatus;
+    isWaitingForInput: boolean;
+    hasMoreMessages: boolean;
+    isLoadingMore: boolean;
+    sendMessage: (content: string, images?: ImageData_2[]) => void;
+    submitUserInput: (value: string) => void;
+    clearMessages: () => void;
+    loadMoreMessages: () => Promise<void>;
+    cancelExecution: () => void;
+    connect: () => Promise<() => void>;
+    disconnect: () => void;
+};
+
+export declare function useAgentConversationContext(): AgentConversationContextValue;
+
+declare interface UseAgentConversationProps {
+    contextId: string;
+    agentName: string;
+    token: string;
+    platformAdapter?: {
+        onPlatformEvent?: (eventName: string, eventData: unknown) => void;
+        onPlatformFunction?: (functionName: string, parameters: unknown, executionId: string) => Promise<unknown>;
+    };
+    onUserInputRequest?: (request: UserInputRequest) => Promise<string>;
+    autoConnect?: boolean;
+}
+
+export declare function useChannelCounts(): UseChannelCountsReturnType;
+
+declare type UseChannelCountsReturnType = {
+    loading: true;
+    counts: never;
+    error: Error | null;
+    refetch: () => Promise<void>;
+} | {
+    loading: false;
+    counts: ChannelCounts;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+
+export declare function useClient(): UseClientReturnType;
+
+declare type UseClientReturnType = {
+    client: Client;
+    loading: boolean;
+};
+
+export declare function useConversationSessions(token: string): UseConversationSessionsReturnType;
+
+declare type UseConversationSessionsReturnType = {
+    sessions: ConversationSession[];
+    loading: boolean;
+    error: Error | null;
+    createSession: (request: CreateSessionRequest) => Promise<ConversationSession>;
+    deleteSession: (id: string) => Promise<void>;
+    refetch: () => Promise<void>;
+};
+
+export declare function useDeployment(): DeploymentContextType_2;
+
+export declare function useForgotPassword(): {
+    error: Error | null;
+    loading: boolean;
+    forgotPassword: (email: string) => Promise<ApiResult<{}, ErrorInterface>>;
+    verifyOtp: (email: string, otp: string) => Promise<ApiResult<{
+        token: string;
+    }, ErrorInterface>>;
+    resetPassword: (token: string, password: string) => Promise<ApiResult<Session, ErrorInterface>>;
+};
+
+export declare const useInvitation: () => {
+    acceptInvitation: (token: string) => Promise<AcceptInvitationResponse>;
+    invitationData: AcceptInvitationResponse | null;
+    loading: boolean;
+    error: string | null;
+    reset: () => void;
+};
+
+export declare function useMagicLinkParams(): MagicLinkParams;
+
+export declare function useMagicLinkVerification(): UseMagicLinkVerificationReturnType;
+
+export declare interface UseMagicLinkVerificationReturnType {
+    loading: boolean;
+    verifyMagicLink: (params: MagicLinkParams) => Promise<ApiResult<{}, ErrorInterface>>;
+    error: Error | null;
+    success: boolean | null;
+}
+
+export declare const useNavigation: () => {
+    navigate: (to: string, options?: NavigateOptions) => void;
+    navigateToSignIn: (redirectUri?: string) => void;
+    navigateToSignUp: (redirectUri?: string) => void;
+};
+
+export declare function useNotifications(params?: NotificationListParams): UseNotificationsReturnType;
+
+declare type UseNotificationsReturnType = {
+    loading: true;
+    notifications: never;
+    unreadCount: never;
+    unreadCounts: never;
+    channels: never;
+    hasMore: never;
+    markAsRead: never;
+    markAllAsRead: never;
+    deleteNotification: never;
+    error: Error | null;
+    refetch: () => Promise<void>;
+} | {
+    loading: false;
+    error: Error | null;
+    notifications: Notification_2[];
+    unreadCount: number;
+    unreadCounts: ChannelCounts;
+    channels: string[];
+    hasMore: boolean;
+    markAsRead: (notificationId: string) => Promise<void>;
+    markAllAsRead: () => Promise<void>;
+    deleteNotification: (notificationId: string) => Promise<void>;
+    refetch: () => Promise<void>;
+};
+
+export declare function useNotificationStream({ enabled, channels, organizationIds, workspaceIds, onNotification, onError, reconnectDelay, maxReconnectAttempts, }?: UseNotificationStreamOptions): {
+    isConnected: boolean;
+    connectionError: string | null;
+    disconnect: () => void;
+    reconnect: () => void;
+};
+
+export declare interface UseNotificationStreamOptions {
+    enabled?: boolean;
+    channels?: string[];
+    organizationIds?: number[];
+    workspaceIds?: number[];
+    onNotification?: (notification: NotificationMessage) => void;
+    onError?: (error: string) => void;
+    reconnectDelay?: number;
+    maxReconnectAttempts?: number;
+}
+
+export declare const useOrganizationList: () => {
+    organizations: Organization[] | undefined;
+    loading: boolean;
+    error: null;
+    refetch: () => Promise<void>;
+    leaveOrganization: (organization: Organization) => Promise<void>;
+    getOrganizationRoles: (organization: Organization) => Promise<OrganizationRole[]>;
+    getOrganizationMembers: (organization: Organization) => Promise<OrganizationMembership[]>;
+    removeOrganizationMember: (organization: Organization, member: OrganizationMembership) => Promise<void>;
+    createOrganization: (organization: NewOrgnization) => Promise<ApiResult<Organization>>;
+    getOrganizationInvitations: (organization: Organization) => Promise<OrganizationInvitation[]>;
+    getOrganizationDomains: (organization: Organization) => Promise<OrganizationDomain[]>;
+    addOrganizationDomain: (organization: Organization, domain: NewDomain) => Promise<ApiResult<OrganizationDomain>>;
+    verifyOrganizationDomain: (organization: Organization, domain: OrganizationDomain) => Promise<ApiResult<OrganizationDomain>>;
+    removeOrganizationDomain: (organization: Organization, domain: OrganizationDomain) => Promise<ApiResult<OrganizationDomain>>;
+    addRoleToOrganizationMember: (organization: Organization, member: OrganizationMembership, role: OrganizationRole) => Promise<OrganizationMembership>;
+    removeRoleFromOrganizationMember: (organization: Organization, member: OrganizationMembership, role: OrganizationRole) => Promise<OrganizationMembership>;
+    inviteOrganizationMember: (organization: Organization, invitation: OrganizationInvitationPayload) => Promise<OrganizationInvitation>;
+    discardOrganizationInvitation: (organization: Organization, invitation: OrganizationInvitation) => Promise<OrganizationInvitation>;
+    resendOrganizationInvitation: (organization: Organization, invitation: OrganizationInvitation) => Promise<OrganizationInvitation>;
+    updateOrganization: (organization: Organization, update: OrganizationUpdate) => Promise<ApiResult<Organization>>;
+    addRole: (organization: Organization, newRole: RoleCreate) => Promise<ApiResult<OrganizationRole>>;
+    removeOrganizationRoles: (organization: Organization, role: OrganizationRole) => Promise<void>;
+    deleteOrganization: (organization: Organization) => Promise<void>;
+};
+
+export declare const useOrganizationMemberships: () => {
+    organizationMemberships: OrganizationMembershipWithOrganization[] | undefined;
+    loading: boolean;
+    error: any;
+    refetch: () => Promise<void>;
+};
+
+export declare const UserButton: default_2.FC<UserButtonProps>;
+
+declare interface UserButtonProps {
+    showName?: boolean;
+}
+
+export declare const UserControls: default_2.FC<UserControlsProps>;
+
+declare interface UserControlsProps {
+    showName?: boolean;
+    showNotifications?: boolean;
+}
+
+export declare interface UserInputRequest {
+    question: string;
+    context: string;
+    input_type: "text" | "number" | "select" | "multiselect" | "boolean" | "date";
+    options?: string[];
+    default_value?: string;
+    placeholder?: string;
+}
+
+declare type UsernameSignInParams = {
+    username: string;
+    password: string;
+};
+
+export declare function useSession(): UseSessionReturnType;
+
+declare type UseSessionReturnType = {
+    loading: true;
+    session: never;
+    switchSignIn: never;
+    switchOrganization: never;
+    switchWorkspace: never;
+    signOut: never;
+    getToken: never;
+    addNewAccount: never;
+    error: Error | null;
+    refetch: () => Promise<void>;
+} | {
+    loading: false;
+    error: Error | null;
+    session: Session;
+    switchSignIn: (signInId: string) => Promise<void>;
+    signOut: (signInId?: string) => Promise<void>;
+    getToken: (template?: string) => Promise<string>;
+    switchOrganization: (organizationId?: string) => Promise<void>;
+    switchWorkspace: (workspaceId: string) => Promise<void>;
+    addNewAccount: () => void;
+    refetch: () => Promise<void>;
+};
+
+export declare function useSignIn(): UseSignInReturnType;
+
+declare type UseSignInReturnType = {
+    loading: false;
+    signIn: SignIn;
+    signinAttempt: SigninAttempt | null;
+    discardSignInAttempt: () => void;
+    setSignInAttempt: (attempt: SigninAttempt | null) => void;
+    error: ApiResult<unknown, ErrorInterface> | null;
+} | {
+    loading: true;
+    signIn: never;
+    signinAttempt: null;
+    discardSignInAttempt: () => void;
+    setSignInAttempt: (attempt: SigninAttempt | null) => void;
+    error: null;
+};
+
+export declare function useSignInWithStrategy<T extends SignInStrategy>(strategy: T): UseSignInWithStrategyReturnType<T>;
+
+export declare type UseSignInWithStrategyReturnType<T extends SignInStrategy> = {
+    loading: true;
+    signIn: never;
+    signinAttempt: null;
+    discardSignInAttempt: () => void;
+    setSignInAttempt: (attempt: SigninAttempt | null) => void;
+    error: null;
+} | {
+    loading: false;
+    signIn: {
+        create: SignInFunction<T>;
+        completeVerification: (verificationCode: string) => Promise<Session>;
+        prepareVerification: (params: VerificationParams) => Promise<ApiResult<PrepareVerificationResponse>>;
+        completeProfile: (data: ProfileCompletionData) => Promise<Session>;
+    };
+    signinAttempt: SigninAttempt | null;
+    discardSignInAttempt: () => void;
+    setSignInAttempt: (attempt: SigninAttempt | null) => void;
+    error: ApiResult<unknown, ErrorInterface> | null;
+};
+
+export declare function useSignUp(): UseSignUpReturnType;
+
+export declare type UseSignUpReturnType = {
+    loading: true;
+    signUp: never;
+    signupAttempt: null;
+    discardSignupAttempt: () => void;
+    errors: null;
+} | {
+    loading: false;
+    signUp: SignUpFunction;
+    signupAttempt: SignupAttempt | null;
+    discardSignupAttempt: () => void;
+    errors: ApiResult<unknown, ErrorInterface> | null;
+};
+
+/**
+ * Headless hook for handling SSO OAuth callback
+ * Automatically processes URL parameters and handles the callback flow
+ */
+export declare function useSSOCallback(): SSOCallbackState;
+
+export declare function useUser(): {
+    user: {
+        refetch: KeyedMutator<CurrentUser>;
+        id?: string | undefined;
+        first_name?: string | undefined;
+        last_name?: string | undefined;
+        username?: string | undefined;
+        availability?: "available" | "busy" | "away" | undefined;
+        has_profile_picture?: string | undefined;
+        profile_picture_url?: string | undefined;
+        primary_email_address_id?: string | undefined;
+        primary_phone_number_id?: string | undefined;
+        primary_email_address?: UserEmailAddress | undefined;
+        primary_phone_number?: UserPhoneNumber;
+        second_factor_policy?: SecondFactorPolicy | undefined;
+        user_email_addresses?: UserEmailAddress[] | undefined;
+        user_phone_numbers?: UserPhoneNumber[] | undefined;
+        email_addresses?: UserEmailAddress[];
+        phone_numbers?: UserPhoneNumber[];
+        social_connections?: SocialConnection[] | undefined;
+        user_authenticator?: UserAuthenticator;
+        authenticators?: UserAuthenticator[];
+        backup_codes_generated?: boolean;
+        backup_codes?: string[];
+        has_password?: boolean | undefined;
+        public_metadata?: Record<string, unknown> | undefined;
+    };
+    loading: boolean;
+    error: any;
+    updateProfile: (data: ProfileUpdateData) => Promise<ApiResult<unknown>>;
+    getEmailAddresses: () => Promise<ApiResult<unknown>>;
+    getEmailAddress: (id: string) => Promise<ApiResult<unknown>>;
+    createEmailAddress: (email: string) => Promise<ApiResult<UserEmailAddress>>;
+    deleteEmailAddress: (id: string) => Promise<ApiResult<unknown>>;
+    prepareEmailVerification: (id: string) => Promise<ApiResult<unknown>>;
+    attemptEmailVerification: (id: string, otp: string) => Promise<ApiResult<unknown>>;
+    makeEmailPrimary: (id: string) => Promise<ApiResult<unknown>>;
+    createPhoneNumber: (phone_number: string, country_code: string) => Promise<ApiResult<UserPhoneNumber>>;
+    deletePhoneNumber: (id: string) => Promise<ApiResult<unknown>>;
+    preparePhoneVerification: (id: string) => Promise<ApiResult<unknown>>;
+    attemptPhoneVerification: (id: string, otp: string) => Promise<ApiResult<unknown>>;
+    makePhonePrimary: (id: string) => Promise<ApiResult<unknown>>;
+    setupAuthenticator: () => Promise<UserAuthenticator>;
+    verifyAuthenticator: (id: string, codes: string[]) => Promise<ApiResult<unknown>>;
+    deleteAuthenticator: (id: string) => Promise<ApiResult<unknown>>;
+    generateBackupCodes: () => Promise<string[]>;
+    regenerateBackupCodes: () => Promise<string[]>;
+    updateProfilePicture: (file: File) => Promise<ApiResult<unknown>>;
+    disconnectSocialConnection: (id: string) => Promise<ApiResult<unknown>>;
+    connectSocialAccount: ({ provider, redirectUri, }: {
+        provider: string;
+        redirectUri?: string;
+    }) => Promise<ApiResult<    {
+    oauth_url: string;
+    }>>;
+    updatePassword: (currentPassword: string, newPassword: string) => Promise<ApiResult<unknown>>;
+    removePassword: (currentPassword: string) => Promise<ApiResult<unknown>>;
+    deleteAccount: (password: string) => Promise<ApiResult<unknown>>;
+};
+
+export declare function useUserSignins(): {
+    signins: SignIn_2[] | undefined;
+    error: any;
+    removeSignin: (id: string) => Promise<ApiResult<unknown>>;
+    refetch: KeyedMutator<SignIn_2[]>;
+    loading: boolean;
+};
+
+export declare function useWaitlist(): {
+    loading: boolean;
+    error: ApiResult<unknown, ErrorInterface> | null;
+    joinWaitlist: (params: WaitlistParams) => Promise<ApiResult<WaitlistResponse, ErrorInterface>>;
+};
+
+export declare const useWorkspaceList: () => {
+    workspaces: WorkspaceWithOrganization[];
+    loading: boolean;
+    error: any;
+    refetch: () => Promise<void>;
+    leaveWorkspace: (id: string, userId: string) => Promise<void>;
+    createWorkspace: (organizationId: string, name: string, image?: File, description?: string) => Promise<Response>;
+    updateWorkspace: (workspace: Workspace, data: {
+        name?: string;
+        description?: string;
+        image?: File;
+    }) => Promise<unknown>;
+    deleteWorkspace: (workspace: Workspace) => Promise<unknown>;
+    getWorkspaceMembers: (workspace: Workspace) => Promise<WorkspaceMembership[]>;
+    getWorkspaceRoles: (workspace: Workspace) => Promise<WorkspaceRole[]>;
+    createWorkspaceRole: (workspace: Workspace, name: string, permissions: string[]) => Promise<WorkspaceRole>;
+    deleteWorkspaceRole: (workspace: Workspace, role: WorkspaceRole) => Promise<unknown>;
+    inviteWorkspaceMember: (workspace: Workspace, email: string, roleId?: string) => Promise<unknown>;
+    removeWorkspaceMember: (workspace: Workspace, memberId: string) => Promise<unknown>;
+    addWorkspaceMemberRole: (workspace: Workspace, membershipId: string, roleId: string) => Promise<unknown>;
+    removeWorkspaceMemberRole: (workspace: Workspace, membershipId: string, roleId: string) => Promise<unknown>;
+};
+
+export declare const useWorkspaceMemberships: () => {
+    workspaceMemberships: WorkspaceMembership[] | undefined;
+    loading: boolean;
+    error: any;
+    refetch: () => Promise<void>;
+};
+
+declare type VerificationParams = EmailOTPVerificationParams | PhoneOTPVerificationParams | MagicLinkVerificationParams;
+
+export declare interface WaitlistEntry {
+    id: string;
+    deployment_id: number;
+    email_address: string;
+    first_name: string;
+    last_name: string;
+    created_at: string;
+    updated_at: string;
+}
+
+export declare function WaitlistForm(): JSX.Element;
+
+export declare interface WaitlistParams {
+    first_name: string;
+    last_name: string;
+    email: string;
+}
+
+export declare interface WaitlistResponse {
+    message: string;
+    entry: WaitlistEntry;
+}
+
+
+export * from "@wacht/types";
+
+export { }