@wacht/jsx 0.0.1-alpha.1

package/dist/hooks/use-agent-conversation.d.ts

@@ -0,0 +1,61 @@
+import { CONNECTION_STATES } from '../constants/ai-agent';
+import { FrontendStatus } from '../constants/execution-status';
+export interface UserInputRequest {
+    question: string;
+    context: string;
+    input_type: "text" | "number" | "select" | "multiselect" | "boolean" | "date";
+    options?: string[];
+    default_value?: string;
+    placeholder?: string;
+}
+export interface ImageData {
+    mime_type: string;
+    data?: string;
+    url?: string;
+}
+export interface ConversationMessage {
+    id: string | number;
+    role: "user" | "assistant" | "system";
+    content: string;
+    timestamp: Date;
+    isStreaming?: boolean;
+    images?: ImageData[];
+    metadata?: {
+        type?: "user_input_request" | "log";
+        userInputRequest?: UserInputRequest;
+        messageType?: string;
+    };
+}
+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 useAgentConversation({ contextId, agentName, token, platformAdapter, autoConnect, }: UseAgentConversationProps): {
+    messages: ConversationMessage[];
+    pendingMessage: string | null;
+    pendingImages: ImageData[] | 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[]) => void;
+    submitUserInput: (value: string) => void;
+    clearMessages: () => void;
+    loadMoreMessages: () => Promise<void>;
+    cancelExecution: () => void;
+    connect: () => Promise<() => void>;
+    disconnect: () => void;
+};
+export {};

package/dist/hooks/use-channel-counts.d.ts

@@ -0,0 +1,14 @@
+import { ChannelCounts } from '../../../../../../../../lib/types/notification';
+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 useChannelCounts(): UseChannelCountsReturnType;
+export {};

package/dist/hooks/use-client.d.ts

@@ -0,0 +1,7 @@
+import { Client } from '../../../../../../../../lib/types';
+type UseClientReturnType = {
+    client: Client;
+    loading: boolean;
+};
+export declare function useClient(): UseClientReturnType;
+export {};

package/dist/hooks/use-context-manager.d.ts

@@ -0,0 +1,30 @@
+export interface ExecutionContext {
+    id: string;
+    title: string;
+    status: 'idle' | 'running' | 'waiting_for_input' | 'interrupted' | 'completed' | 'failed';
+    last_activity_at: string;
+    context_group?: string;
+    created_at: string;
+}
+export interface CreateContextRequest {
+    title: string;
+}
+export interface ListContextsOptions {
+    limit?: number;
+    offset?: number;
+    status?: string;
+}
+export interface ListContextsResponse {
+    data: ExecutionContext[];
+    has_more: boolean;
+}
+type UseContextManagerReturnType = {
+    contexts: ExecutionContext[];
+    loading: boolean;
+    error: Error | null;
+    createContext: (request: CreateContextRequest) => Promise<ExecutionContext>;
+    deleteContext: (id: string) => Promise<void>;
+    refetch: () => Promise<void>;
+};
+export declare function useContextManager(token: string): UseContextManagerReturnType;
+export {};

package/dist/hooks/use-conversation-sessions.d.ts

@@ -0,0 +1,32 @@
+export 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 interface CreateSessionRequest {
+    title: string;
+    system_instructions?: string;
+}
+export interface ListSessionsOptions {
+    limit?: number;
+    offset?: number;
+    status?: string;
+    search?: string;
+}
+export interface ListSessionsResponse {
+    data: ConversationSession[];
+    has_more: boolean;
+}
+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 useConversationSessions(token: string): UseConversationSessionsReturnType;
+export {};

package/dist/hooks/use-deployment.d.ts

@@ -0,0 +1 @@
+export declare function useDeployment(): import('..').DeploymentContextType;

package/dist/hooks/use-forgot-password.d.ts

@@ -0,0 +1,11 @@
+import { ApiResult, ErrorInterface } from '../../../../../../../../lib/types';
+export declare function useForgotPassword(): {
+    loading: boolean;
+    forgotPassword: (email: string) => Promise<ApiResult<{}, ErrorInterface>>;
+    error: Error | null;
+};
+export declare function useResetPassword(): {
+    loading: boolean;
+    resetPassword: (email: string, otp: string, password: string) => Promise<ApiResult<{}, ErrorInterface>>;
+    error: Error | null;
+};

package/dist/hooks/use-invitation.d.ts

@@ -0,0 +1,23 @@
+export 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 const useInvitation: () => {
+    acceptInvitation: (token: string) => Promise<AcceptInvitationResponse>;
+    invitationData: AcceptInvitationResponse | null;
+    loading: boolean;
+    error: string | null;
+    reset: () => void;
+};

package/dist/hooks/use-magic-link.d.ts

@@ -0,0 +1,14 @@
+import { ApiResult, ErrorInterface } from '../../../../../../../../lib/types';
+export interface MagicLinkParams {
+    token?: string;
+    attempt?: string;
+    redirectUri?: string;
+}
+export interface UseMagicLinkVerificationReturnType {
+    loading: boolean;
+    verifyMagicLink: (params: MagicLinkParams) => Promise<ApiResult<{}, ErrorInterface>>;
+    error: Error | null;
+    success: boolean | null;
+}
+export declare function useMagicLinkVerification(): UseMagicLinkVerificationReturnType;
+export declare function useMagicLinkParams(): MagicLinkParams;

package/dist/hooks/use-navigation.d.ts

@@ -0,0 +1,6 @@
+import { NavigateOptions } from '../../../../../../../../lib/types/platform-adapter';
+export declare const useNavigation: () => {
+    navigate: (to: string, options?: NavigateOptions) => void;
+    navigateToSignIn: (redirectUri?: string) => void;
+    navigateToSignUp: (redirectUri?: string) => void;
+};

package/dist/hooks/use-notification-stream.d.ts

@@ -0,0 +1,27 @@
+export 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 interface UseNotificationStreamOptions {
+    enabled?: boolean;
+    channels?: string[];
+    organizationIds?: number[];
+    workspaceIds?: number[];
+    onNotification?: (notification: NotificationMessage) => void;
+    onError?: (error: string) => void;
+    reconnectDelay?: number;
+    maxReconnectAttempts?: number;
+}
+export declare function useNotificationStream({ enabled, channels, organizationIds, workspaceIds, onNotification, onError, reconnectDelay, maxReconnectAttempts, }?: UseNotificationStreamOptions): {
+    isConnected: boolean;
+    connectionError: string | null;
+    disconnect: () => void;
+    reconnect: () => void;
+};

package/dist/hooks/use-notifications.d.ts

@@ -0,0 +1,30 @@
+import { Notification, NotificationListParams, ChannelCounts } from '../../../../../../../../lib/types/notification';
+import { Client } from '../../../../../../../../lib/types';
+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[];
+    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 fetchChannelCounts(client: Client): Promise<ChannelCounts>;
+export declare function useNotifications(params?: NotificationListParams): UseNotificationsReturnType;
+export {};

package/dist/hooks/use-organization.d.ts

@@ -0,0 +1,81 @@
+import { NewDomain, NewOrgnization, Organization, OrganizationDomain, OrganizationInvitation, OrganizationInvitationPayload, OrganizationMembership, OrganizationMembershipWithOrganization, OrganizationRole, OrganizationUpdate, RoleCreate } from '../../../../../../../../lib/types';
+export declare const useOrganizationList: () => {
+    organizations: Organization[] | undefined;
+    loading: boolean;
+    error: null;
+    refetch: import('swr').KeyedMutator<OrganizationMembershipWithOrganization[]>;
+    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<import('@snipextt/wacht-types').ApiResult<Organization>>;
+    getOrganizationInvitations: (organization: Organization) => Promise<OrganizationInvitation[]>;
+    getOrganizationDomains: (organization: Organization) => Promise<OrganizationDomain[]>;
+    addOrganizationDomain: (organization: Organization, domain: NewDomain) => Promise<import('@snipextt/wacht-types').ApiResult<OrganizationDomain>>;
+    verifyOrganizationDomain: (organization: Organization, domain: OrganizationDomain) => Promise<import('@snipextt/wacht-types').ApiResult<OrganizationDomain>>;
+    removeOrganizationDomain: (organization: Organization, domain: OrganizationDomain) => Promise<import('@snipextt/wacht-types').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<import('@snipextt/wacht-types').ApiResult<Organization>>;
+    addRole: (organization: Organization, newRole: RoleCreate) => Promise<import('@snipextt/wacht-types').ApiResult<OrganizationRole>>;
+    removeOrganizationRoles: (organization: Organization, role: OrganizationRole) => Promise<void>;
+    deleteOrganization: (organization: Organization) => Promise<void>;
+};
+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: import('swr').KeyedMutator<OrganizationMembershipWithOrganization[]>;
+    getRoles: () => Promise<OrganizationRole[]>;
+    updateOrganization: (update: OrganizationUpdate) => Promise<{
+        data: never;
+        errors: import('@snipextt/wacht-types').ErrorInterface[];
+    } | never[] | {
+        data: Organization;
+        errors: never;
+    }>;
+    getMembers: () => Promise<OrganizationMembership[]>;
+    getDomains: () => Promise<OrganizationDomain[]>;
+    addDomain: (domain: NewDomain) => Promise<import('@snipextt/wacht-types').ApiResult<OrganizationDomain> | undefined>;
+    verifyDomain: (domain: OrganizationDomain) => Promise<import('@snipextt/wacht-types').ApiResult<OrganizationDomain> | undefined>;
+    removeDomain: (domain: OrganizationDomain) => Promise<import('@snipextt/wacht-types').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 const useOrganizationMemberships: () => {
+    organizationMemberships: OrganizationMembershipWithOrganization[] | undefined;
+    loading: boolean;
+    error: any;
+    refetch: import('swr').KeyedMutator<OrganizationMembershipWithOrganization[]>;
+};

package/dist/hooks/use-session.d.ts

@@ -0,0 +1,26 @@
+import { Session } from '../../../../../../../../lib/types';
+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 useSession(): UseSessionReturnType;
+export {};

package/dist/hooks/use-signin.d.ts

@@ -0,0 +1,140 @@
+import { ApiResult, ErrorInterface, Session, SigninAttempt, ProfileCompletionData } from '../../../../../../../../lib/types';
+type UsernameSignInParams = {
+    username: string;
+    password: string;
+};
+type SignInPlainUsername = ({ username, password, }: UsernameSignInParams) => Promise<ApiResult<Session>>;
+type EmailSignInParams = {
+    email: string;
+    password: string;
+};
+type SignInPlainEmail = ({ email, password, }: EmailSignInParams) => Promise<ApiResult<Session>>;
+type GenericSignInParams = {
+    email?: string;
+    username?: string;
+    password?: string;
+    phone?: string;
+    strategy?: string;
+};
+type SignInGeneric = ({ email, username, password, phone, strategy, }: GenericSignInParams) => Promise<ApiResult<Session>>;
+type PhoneSignInParams = {
+    phone: string;
+};
+type SignInPhone = ({ phone, }: PhoneSignInParams) => Promise<ApiResult<Session>>;
+type EmailOTPSignInParams = {
+    email: string;
+};
+type SignInEmailOTP = ({ email, }: EmailOTPSignInParams) => Promise<ApiResult<Session>>;
+type MagicLinkSignInParams = {
+    email: string;
+};
+type SignInMagicLink = ({ email, }: MagicLinkSignInParams) => Promise<ApiResult<Session>>;
+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"
+}
+type SignInOauth = ({ provider, redirectUri, }: {
+    provider: OAuthProvider;
+    redirectUri?: string;
+}) => Promise<ApiResult<InitSSOResponseType>>;
+export declare enum SignInStrategy {
+    Username = "username",
+    Email = "email",
+    Phone = "phone",
+    EmailOTP = "email_otp",
+    MagicLink = "magic_link",
+    Oauth = "oauth",
+    Generic = "generic"
+}
+type EmailOTPVerificationParams = {
+    strategy: "email_otp";
+    redirectUri?: string;
+};
+type PhoneOTPVerificationParams = {
+    strategy: "phone_otp";
+    lastDigits?: string;
+};
+type MagicLinkVerificationParams = {
+    strategy: "magic_link";
+    redirectUri?: string;
+};
+type VerificationParams = EmailOTPVerificationParams | PhoneOTPVerificationParams | MagicLinkVerificationParams;
+type PrepareVerificationResponse = {
+    otp_sent?: boolean;
+    masked_phone?: string;
+    masked_email?: string;
+    verification_method?: string;
+};
+type CreateSignInStrategyResult = {
+    (strategy: SignInStrategy.Username): SignInPlainUsername;
+    (strategy: SignInStrategy.Email): SignInPlainEmail;
+    (strategy: SignInStrategy.Phone): SignInPhone;
+    (strategy: SignInStrategy.EmailOTP): SignInEmailOTP;
+    (strategy: SignInStrategy.MagicLink): SignInMagicLink;
+    (strategy: SignInStrategy.Oauth): SignInOauth;
+    (strategy: SignInStrategy.Generic): SignInGeneric;
+};
+type SignIn = {
+    createStrategy: CreateSignInStrategyResult;
+    prepareVerification: (params: VerificationParams) => Promise<ApiResult<PrepareVerificationResponse>>;
+    completeVerification: (verificationCode: string) => Promise<Session>;
+    completeProfile: (data: ProfileCompletionData) => Promise<Session>;
+};
+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;
+};
+type InitSSOResponseType = {
+    oauth_url: string;
+    session: Session;
+};
+export declare function useSignIn(): UseSignInReturnType;
+type SignInFunction<T extends SignInStrategy> = {
+    [SignInStrategy.Username]: SignInPlainUsername;
+    [SignInStrategy.Email]: SignInPlainEmail;
+    [SignInStrategy.Phone]: SignInPhone;
+    [SignInStrategy.EmailOTP]: SignInEmailOTP;
+    [SignInStrategy.MagicLink]: SignInMagicLink;
+    [SignInStrategy.Oauth]: SignInOauth;
+    [SignInStrategy.Generic]: SignInGeneric;
+}[T];
+export 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 useSignInWithStrategy<T extends SignInStrategy>(strategy: T): UseSignInWithStrategyReturnType<T>;
+export {};

package/dist/hooks/use-signup.d.ts

@@ -0,0 +1,46 @@
+import { ApiResult, ErrorInterface, Session, SignupAttempt, SignUpParams } from '../../../../../../../../lib/types';
+export interface DeploymentInvitationData {
+    valid: boolean;
+    first_name?: string;
+    last_name?: string;
+    email?: string;
+    message?: string;
+    error_code?: string;
+}
+export type SignUpFunction = {
+    create: (params: SignUpParams) => Promise<ApiResult<unknown, ErrorInterface>>;
+    prepareVerification: (params: SignupVerificationParams) => Promise<ApiResult<PrepareVerificationResponse>>;
+    completeVerification: (verificationCode: string) => Promise<ApiResult<Session>>;
+    validateDeploymentInvitation: (token: string) => Promise<DeploymentInvitationData>;
+};
+export type SignupVerificationStrategy = "email_otp" | "phone_otp";
+type SignupEmailOTPVerificationParams = {
+    strategy: "email_otp";
+    redirectUri?: string;
+};
+type SignupPhoneOTPVerificationParams = {
+    strategy: "phone_otp";
+    lastDigits?: string;
+};
+type SignupVerificationParams = SignupEmailOTPVerificationParams | SignupPhoneOTPVerificationParams;
+type PrepareVerificationResponse = {
+    otp_sent?: boolean;
+    masked_phone?: string;
+    masked_email?: string;
+    verification_method?: string;
+};
+export 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;
+};
+export declare function useSignUp(): UseSignUpReturnType;
+export {};

package/dist/hooks/use-sso-callback.d.ts

@@ -0,0 +1,15 @@
+import { Session, SigninAttempt } from '../../../../../../../../lib/types';
+interface SSOCallbackState {
+    loading: boolean;
+    error: Error | null;
+    session: Session | null;
+    redirectUri: string | null;
+    processed: boolean;
+    signinAttempt: SigninAttempt | null;
+}
+/**
+ * Headless hook for handling SSO OAuth callback
+ * Automatically processes URL parameters and handles the callback flow
+ */
+export declare function useSSOCallback(): SSOCallbackState;
+export {};

package/dist/hooks/use-user.d.ts

@@ -0,0 +1,78 @@
+import { CurrentUser, UserAuthenticator, UserEmailAddress, UserPhoneNumber, SignIn } from '../../../../../../../../lib/types';
+type SecondFactorPolicy = "none" | "optional" | "enforced";
+interface ProfileUpdateData {
+    first_name?: string;
+    last_name?: string;
+    username?: string;
+    primary_email_address_id?: string;
+    primary_phone_number_id?: string;
+    second_factor_policy?: SecondFactorPolicy;
+    remove_profile_picture?: boolean;
+}
+export declare function useUser(): {
+    user: {
+        refetch: import('swr').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?: import('@snipextt/wacht-types').SecondFactorPolicy | undefined;
+        user_email_addresses?: UserEmailAddress[] | undefined;
+        user_phone_numbers?: UserPhoneNumber[] | undefined;
+        email_addresses?: UserEmailAddress[];
+        phone_numbers?: UserPhoneNumber[];
+        social_connections?: import('@snipextt/wacht-types').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<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    getEmailAddresses: () => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    getEmailAddress: (id: string) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    createEmailAddress: (email: string) => Promise<import('@snipextt/wacht-types').ApiResult<UserEmailAddress>>;
+    deleteEmailAddress: (id: string) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    prepareEmailVerification: (id: string) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    attemptEmailVerification: (id: string, otp: string) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    makeEmailPrimary: (id: string) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    createPhoneNumber: (phone_number: string, country_code: string) => Promise<import('@snipextt/wacht-types').ApiResult<UserPhoneNumber>>;
+    deletePhoneNumber: (id: string) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    preparePhoneVerification: (id: string) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    attemptPhoneVerification: (id: string, otp: string) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    makePhonePrimary: (id: string) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    setupAuthenticator: () => Promise<UserAuthenticator>;
+    verifyAuthenticator: (id: string, codes: string[]) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    deleteAuthenticator: (id: string) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    generateBackupCodes: () => Promise<string[]>;
+    regenerateBackupCodes: () => Promise<string[]>;
+    updateProfilePicture: (file: File) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    disconnectSocialConnection: (id: string) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    connectSocialAccount: ({ provider, redirectUri }: {
+        provider: string;
+        redirectUri?: string;
+    }) => Promise<import('@snipextt/wacht-types').ApiResult<{
+        oauth_url: string;
+    }>>;
+    updatePassword: (currentPassword: string, newPassword: string) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    removePassword: (currentPassword: string) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    deleteAccount: (password: string) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+};
+export declare function useUserSignins(): {
+    signins: SignIn[] | undefined;
+    error: any;
+    removeSignin: (id: string) => Promise<import('@snipextt/wacht-types').ApiResult<unknown>>;
+    refetch: import('swr').KeyedMutator<SignIn[]>;
+    loading: boolean;
+};
+export {};