@niledatabase/react 3.0.0-alpha.9 → 3.0.1-alpha.0

package/dist/index.d.mts

@@ -0,0 +1,355 @@
+import * as React from 'react';
+import React__default from 'react';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { QueryClient } from '@tanstack/react-query';
+import * as next_auth_react from 'next-auth/react';
+import { SignInOptions, UseSessionOptions, LiteralUnion, ClientSafeProvider, SignInAuthorizationParams, SignInResponse, SignOutParams, SignOutResponse, SessionProviderProps } from 'next-auth/react';
+import * as class_variance_authority_dist_types from 'class-variance-authority/dist/types';
+import { VariantProps } from 'class-variance-authority';
+import { CreateBasicUserRequest } from '@niledatabase/browser';
+import { BuiltInProviderType, RedirectableProviderType } from 'next-auth/providers/index';
+import { CtxOrReq } from 'next-auth/client/_utils';
+import { Session } from 'next-auth';
+
+type EmailSignInInfo = SignInOptions;
+type SignInSuccess = (response: Response) => void;
+type AllowedAny$3 = any;
+interface Props$5 {
+    redirect?: boolean;
+    onSuccess?: SignInSuccess;
+    onError?: (e: Error, info: EmailSignInInfo) => void;
+    beforeMutate?: (data: AllowedAny$3) => AllowedAny$3;
+    buttonText?: string;
+    client?: QueryClient;
+    callbackUrl?: string;
+}
+
+declare function EmailSigningIn(props: Props$5): React__default.JSX.Element;
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_dist_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    loading?: boolean;
+}
+
+type EmailError = void | {
+    error: string;
+    ok: boolean;
+    status: number;
+    url: null | string;
+};
+/**
+ * This works when the email identity provider is configured in the admin dashboard.
+ * @param props callbackUrl: the url to send the user to from their email
+ * @param props redirect: redirect to the default (unbranded) 'check your email' page. default is false
+ * @param props email:  the email to send to
+ * @param props onSent:  called if the email was sent
+ * @param props onFailure:  called if there was a reportable
+ * @returns a JSX.Element to render
+ */
+declare const EmailSignInButton: React__default.ForwardRefExoticComponent<ButtonProps & {
+    callbackUrl?: string;
+    redirect?: boolean;
+    email: string;
+    onSent?: () => void;
+    onFailure?: (error: EmailError) => void;
+    buttonText?: string;
+} & React__default.RefAttributes<HTMLButtonElement>>;
+
+declare function useEmailSignIn(params?: Props$5): _tanstack_react_query.UseMutateFunction<Response, Error, next_auth_react.SignInOptions, unknown>;
+
+/**
+ * A component for a Google login button, according to their design language.
+ * This works when an identity provider is configured in the admin dashboard.
+ * @param props callbackUrl: a string to override the URL provided by the context
+ * @returns a JSX.Element to render
+ */
+declare const GoogleSSOButton: React__default.ForwardRefExoticComponent<ButtonProps & {
+    callbackUrl?: string;
+    buttonText?: string;
+} & React__default.RefAttributes<HTMLButtonElement>>;
+
+declare const AzureSignInButton: React__default.ForwardRefExoticComponent<ButtonProps & {
+    callbackUrl?: string;
+    buttonText?: string;
+} & React__default.RefAttributes<HTMLButtonElement>>;
+
+declare const DiscordSignInButton: React__default.ForwardRefExoticComponent<ButtonProps & {
+    callbackUrl?: string;
+    buttonText?: string;
+} & React__default.RefAttributes<HTMLButtonElement>>;
+
+declare const GitHubSignInButton: React__default.ForwardRefExoticComponent<ButtonProps & {
+    callbackUrl?: string;
+    buttonText?: string;
+} & React__default.RefAttributes<HTMLButtonElement>>;
+
+declare const HubSpotSignInButton: React__default.ForwardRefExoticComponent<ButtonProps & {
+    callbackUrl?: string;
+    buttonText?: string;
+} & React__default.RefAttributes<HTMLButtonElement>>;
+
+declare const LinkedInSignInButton: React__default.ForwardRefExoticComponent<ButtonProps & {
+    callbackUrl?: string;
+    buttonText?: string;
+} & React__default.RefAttributes<HTMLButtonElement>>;
+
+declare const SlackSignInButton: React__default.ForwardRefExoticComponent<ButtonProps & {
+    callbackUrl?: string;
+    buttonText?: string;
+} & React__default.RefAttributes<HTMLButtonElement>>;
+
+declare const XSignInButton: React__default.ForwardRefExoticComponent<ButtonProps & {
+    callbackUrl?: string;
+    buttonText?: string;
+} & React__default.RefAttributes<HTMLButtonElement>>;
+
+type SignUpInfo = CreateBasicUserRequest & {
+    tenantId?: string;
+    fetchUrl?: string;
+    callbackUrl?: string;
+    newTenantName?: string;
+};
+type AllowedAny$2 = any;
+interface Props$4 {
+    onSuccess?: (response: Response, formValues: SignUpInfo) => void;
+    onError?: (e: Error, info: SignUpInfo) => void;
+    beforeMutate?: (data: AllowedAny$2) => AllowedAny$2;
+    buttonText?: string;
+    client?: QueryClient;
+    callbackUrl?: string;
+    baseUrl?: string;
+    createTenant?: string | boolean;
+}
+
+declare function SigningUp(props: Props$4): React__default.JSX.Element;
+
+declare function useSignUp<T extends SignUpInfo>(params: Props$4, client?: QueryClient): _tanstack_react_query.UseMutateFunction<Response, Error, SignUpInfo, unknown>;
+
+type AllowedAny$1 = any;
+type LoginInfo = {
+    email: string;
+    password: string;
+};
+type LoginSuccess = (response: AllowedAny$1, formValues: LoginInfo, ...args: AllowedAny$1) => void;
+interface Props$3 {
+    beforeMutate?: (data: AllowedAny$1) => AllowedAny$1;
+    onSuccess?: LoginSuccess;
+    onError?: (error: Error, data: AllowedAny$1) => void;
+    callbackUrl?: string;
+    client?: QueryClient;
+}
+
+declare function SigningIn(props: Props$3): React__default.JSX.Element;
+
+declare function useSignIn(params?: Props$3): _tanstack_react_query.UseMutateFunction<next_auth_react.SignInResponse | undefined, Error, LoginInfo, any>;
+
+declare const SignOutButton: React__default.ForwardRefExoticComponent<ButtonProps & {
+    redirect?: boolean;
+    callbackUrl?: string;
+    buttonText?: string;
+} & React__default.RefAttributes<HTMLButtonElement>>;
+
+type UpdateSession = (data?: any) => Promise<Session | null>;
+type SessionContextValue<R extends boolean = false> = R extends true ? {
+    update: UpdateSession;
+    data: Session;
+    status: 'authenticated';
+} | {
+    update: UpdateSession;
+    data: null;
+    status: 'loading';
+} : {
+    update: UpdateSession;
+    data: Session;
+    status: 'authenticated';
+} | {
+    update: UpdateSession;
+    data: null;
+    status: 'unauthenticated' | 'loading';
+};
+declare const SessionContext: React__default.Context<{
+    update: UpdateSession;
+    data: Session;
+    status: "authenticated";
+} | {
+    update: UpdateSession;
+    data: null;
+    status: "unauthenticated" | "loading";
+} | undefined>;
+/**
+ * React Hook that gives you access
+ * to the logged in user's session data.
+ *
+ * [Documentation](https://next-auth.js.org/getting-started/client#usesession)
+ */
+declare function useSession<R extends boolean>(options?: UseSessionOptions<R>): SessionContextValue<R>;
+type GetSessionParams = CtxOrReq & {
+    event?: 'storage' | 'timer' | 'hidden' | string;
+    triggerEvent?: boolean;
+    broadcast?: boolean;
+};
+declare function getSession(params?: GetSessionParams): Promise<Session | null>;
+/**
+ * Returns the current Cross Site Request Forgery Token (CSRF Token)
+ * required to make POST requests (e.g. for signing in and signing out).
+ * You likely only need to use this if you are not using the built-in
+ * `signIn()` and `signOut()` methods.
+ *
+ * [Documentation](https://next-auth.js.org/getting-started/client#getcsrftoken)
+ */
+declare function getCsrfToken(params?: CtxOrReq): Promise<string | undefined>;
+/**
+ * It calls `/api/auth/providers` and returns
+ * a list of the currently configured authentication providers.
+ * It can be useful if you are creating a dynamic custom sign in page.
+ *
+ * [Documentation](https://next-auth.js.org/getting-started/client#getproviders)
+ */
+declare function getProviders(): Promise<Record<LiteralUnion<BuiltInProviderType>, ClientSafeProvider> | null>;
+/**
+ * Client-side method to initiate a signin flow
+ * or send the user to the signin page listing all possible providers.
+ * Automatically adds the CSRF token to the request.
+ *
+ * [Documentation](https://next-auth.js.org/getting-started/client#signin)
+ */
+declare function signIn<P extends RedirectableProviderType | undefined = undefined>(provider?: LiteralUnion<P extends RedirectableProviderType ? P | BuiltInProviderType : BuiltInProviderType>, options?: SignInOptions, authorizationParams?: SignInAuthorizationParams): Promise<P extends RedirectableProviderType ? SignInResponse | undefined : undefined>;
+/**
+ * Signs the user out, by removing the session cookie.
+ * Automatically adds the CSRF token to the request.
+ *
+ * [Documentation](https://next-auth.js.org/getting-started/client#signout)
+ */
+declare function signOut<R extends boolean = true>(options?: SignOutParams<R>): Promise<R extends true ? undefined : SignOutResponse>;
+/**
+ * Provider to wrap the app in to make session data available globally.
+ * Can also be used to throttle the number of requests to the endpoint
+ * `/api/auth/session`.
+ *
+ * [Documentation](https://next-auth.js.org/getting-started/client#sessionprovider)
+ */
+declare function SessionProvider(props: SessionProviderProps): React__default.JSX.Element;
+type JWT = {
+    email: string;
+    sub: string;
+    id: string;
+    iat: number;
+    exp: number;
+    jti: string;
+};
+type ActiveSession = {
+    id: string;
+    email: string;
+    expires: string;
+    user?: {
+        id: string;
+        name: string;
+        image: string;
+        email: string;
+        emailVerified: void | Date;
+    };
+};
+type NonErrorSession = JWT | ActiveSession | null | undefined;
+type NileSession = Response | NonErrorSession;
+
+declare function SignedIn({ children, session: startSession, ...props }: Omit<SessionProviderProps, 'session'> & {
+    session?: NileSession;
+    className?: string;
+}): React__default.JSX.Element | null;
+
+declare function SignedOut({ children, session: startSession, ...props }: Omit<SessionProviderProps, 'session'> & {
+    session?: NileSession;
+    className?: string;
+}): React__default.JSX.Element | null;
+
+type Tenant = {
+    id: string;
+    name: string;
+};
+
+type HookProps = {
+    tenants?: Tenant[];
+    onError?: (e: Error) => void;
+    baseUrl?: string;
+};
+type ComponentProps = HookProps & {
+    client?: QueryClient;
+    activeTenant?: string;
+    useCookie?: boolean;
+    className?: string;
+};
+
+declare function useTenants(params: HookProps & {
+    disableQuery?: boolean;
+}, client?: QueryClient): _tanstack_react_query.UseQueryResult<Tenant[], Error>;
+declare function useTenantId(params?: HookProps & {
+    tenant: Tenant;
+}, client?: QueryClient): [string | undefined, (tenant: string) => void];
+
+declare function TenantSelector(props: ComponentProps): React__default.JSX.Element;
+
+interface User {
+    id: string;
+    email: string;
+    name?: string | null;
+    familyName?: string | null;
+    givenName?: string | null;
+    picture?: string | null;
+    created: string;
+    updated?: string;
+    emailVerified?: string | null;
+    tenants: {
+        id: string;
+    }[];
+}
+
+type Props$2 = {
+    fetchUrl?: string;
+    user?: User | undefined | null;
+};
+declare function useMe(props: Props$2): User | null | undefined;
+
+type Props$1 = {
+    user?: User | undefined | null;
+    fetchUrl?: string;
+    profilePicturePlaceholder?: React__default.ReactElement;
+    className?: string;
+};
+declare function UserInfo(props: Props$1): React__default.JSX.Element | "Loading...";
+
+type Props = Params & {
+    client?: QueryClient;
+    callbackUrl?: string;
+    defaultValues?: MutateFnParams & {
+        confirmPassword?: string;
+    };
+};
+type AllowedAny = any;
+interface Params {
+    beforeMutate?: (data: AllowedAny) => AllowedAny;
+    onSuccess?: (res: Response) => void;
+    onError?: (error: Error, data: AllowedAny) => void;
+    callbackUrl?: string;
+    client?: QueryClient;
+    fetchUrl?: string;
+    baseUrl?: string;
+}
+type MutateFnParams = {
+    email?: string;
+    password?: string;
+};
+
+declare function ResetPasswordForm$1(props: Props): React__default.JSX.Element;
+
+declare function ResetPasswordForm(params: Params): React__default.JSX.Element;
+
+declare function useResetPassword(params?: Params): _tanstack_react_query.UseMutateFunction<Response, Error, MutateFnParams, unknown>;
+
+declare const Email: () => React.JSX.Element;
+declare const Password: () => React.JSX.Element;
+
+export { AzureSignInButton as Azure, DiscordSignInButton as Discord, Email, EmailSigningIn as EmailSignIn, EmailSignInButton, GitHubSignInButton as GitHub, GoogleSSOButton as Google, HubSpotSignInButton as HubSpot, LinkedInSignInButton as LinkedIn, Password, ResetPasswordForm as PasswordResetForm, ResetPasswordForm$1 as PasswordResetRequestForm, SessionContext, SessionProvider, SigningIn as SignInForm, SignOutButton, SigningUp as SignUpForm, SignedIn, SignedOut, SlackSignInButton as Slack, TenantSelector, UserInfo, XSignInButton as X, getCsrfToken, getProviders, getSession, signIn, signOut, useEmailSignIn, useMe, useResetPassword, useSession, useSignIn, useSignUp, useTenantId, useTenants };