@atlasauth/react 0.1.17 → 0.1.19

package/dist/components.d.ts

@@ -1,430 +1,32 @@
-import { type ReactNode } from 'react';
-import { type ReauthInput } from '@atlasauth/js';
-import { type FlowState } from './fapi';
-import { useOrganization } from './hooks';
-import { type ProtectCondition } from './protect';
-import type { AtlasBillingInvoice, AtlasBillingPlan, AtlasBillingSubscription, AtlasPaymentMethod } from './types';
-export declare function SignedIn({ children }: {
-    children: ReactNode;
-}): import("react").JSX.Element | null;
-export declare function SignedOut({ children }: {
-    children: ReactNode;
-}): import("react").JSX.Element | null;
-/** §10.2: render children only while the SDK is still loading. */
-export declare function AtlasLoading({ children }: {
-    children: ReactNode;
-}): import("react").JSX.Element | null;
-/** §10.2: render children only once the SDK has finished loading — the
- * symmetric partner of {@link AtlasLoading}, so a consumer can show a spinner
- * and its resolved content without hand-rolling the inverse condition. */
-export declare function AtlasLoaded({ children }: {
-    children: ReactNode;
-}): import("react").JSX.Element | null;
 /**
- * §10.2 `<Protect permission="…">`.
+ * §10.2 components — public aggregation point for the @atlasauth/react component
+ * library.
  *
- * A rendering helper, never an authorization boundary — anyone can flip the
- * condition in devtools. The server checking the same permission is what
- * actually stops them, and this component's job is only to avoid showing a
- * button that would fail.
- */
-export declare function Protect({ children, fallback, ...condition }: ProtectCondition & {
-    children: ReactNode;
-    fallback?: ReactNode;
-}): import("react").JSX.Element | null;
-export interface FlowProps {
-    /** Where to send the user once the flow completes. */
-    afterUrl?: string;
-    /**
-     * Also show Google One-Tap above the "Sign in with Google" button. OFF by
-     * default: the button alone (a user-initiated popup) converts better and never
-     * surprises the user with an auto-prompt. One-Tap is a separate GSI call, so
-     * this only adds it — the button is unaffected.
-     */
-    googleOneTap?: boolean;
-}
-export declare function SignIn(props?: FlowProps): import("react").JSX.Element;
-/**
- * §6 headless native sign-in, for a consumer that renders its OWN Google button
- * (or Apple / Facebook Limited Login). Mint a nonce with `mintNonce(provider)`,
- * hand it to the provider SDK, then pass the resulting id_token to
- * `signInWithIdToken` — it posts to the native endpoint, exchanges the ticket
- * for cookies and re-boots the app on completion, returning the flow state so
- * the caller can react to `needs_second_factor` etc.
- */
-export declare function useSignIn(): {
-    mintNonce: (provider: string) => Promise<string | null>;
-    signInWithIdToken: (input: {
-        provider: string;
-        idToken: string;
-        nonce?: string;
-    }) => Promise<FlowState>;
-};
-export declare function SignUp(_props?: FlowProps): import("react").JSX.Element;
-/**
- * §L3 prebuilt-component EXTENSION API (Clerk `<UserButton.MenuItems>` /
- * `<UserButton.Action>` / `<UserButton.Link>`).
- *
- * These are *descriptor* components: they render nothing on their own. A parent
- * (`<UserButton>`) walks its children, matches these by identity, and turns each
- * into a real menu entry it controls — so custom items sit inside the prebuilt
- * dropdown's markup/appearance rather than being bolted on outside it. This is
- * the same static-subcomponent pattern Clerk uses (`UserButton.Action`, etc.).
- */
-export interface MenuActionProps {
-    /** The row's text. */
-    label: ReactNode;
-    /** Optional leading icon/element. */
-    labelIcon?: ReactNode;
-    /** Invoked when the row is chosen. */
-    onClick?: () => void;
-}
-export interface MenuLinkProps {
-    label: ReactNode;
-    labelIcon?: ReactNode;
-    /** Where the row navigates. */
-    href: string;
-}
-/** A container for custom `<UserButton.Action>` / `<UserButton.Link>` rows. Renders nothing itself. */
-declare function UserButtonMenuItems(_props: {
-    children?: ReactNode;
-}): null;
-/** A custom action row inside `<UserButton.MenuItems>`. Renders nothing itself. */
-declare function UserButtonAction(_props: MenuActionProps): null;
-/** A custom link row inside `<UserButton.MenuItems>`. Renders nothing itself. */
-declare function UserButtonLink(_props: MenuLinkProps): null;
-/**
- * The signed-in user's avatar + dropdown. Pass `<UserButton.MenuItems>` children
- * to add custom `<UserButton.Action>` / `<UserButton.Link>` rows above sign-out.
- */
-export declare function UserButton({ children }?: {
-    children?: ReactNode;
-}): import("react").JSX.Element | null;
-export declare namespace UserButton {
-    var MenuItems: typeof UserButtonMenuItems;
-    var Action: typeof UserButtonAction;
-    var Link: typeof UserButtonLink;
-}
-export interface AuthButtonProps {
-    /** Where the sign-in / sign-up page lives. Defaults to `/sign-in` / `/sign-up`. */
-    url?: string;
-    /** Where to return after auth completes (becomes `?redirect_url=`). */
-    redirectUrl?: string;
-    children?: ReactNode;
-    className?: string;
-}
-/** Clerk-parity ergonomic: a button that sends the user to your sign-in page. */
-export declare function SignInButton({ url, redirectUrl, children, className }: AuthButtonProps): import("react").JSX.Element;
-/** Clerk-parity ergonomic: a button that sends the user to your sign-up page. */
-export declare function SignUpButton({ url, redirectUrl, children, className }: AuthButtonProps): import("react").JSX.Element;
-/** Clerk-parity ergonomic: a button that signs the user out, then optionally redirects. */
-export declare function SignOutButton({ redirectUrl, children, className, }: {
-    redirectUrl?: string;
-    children?: ReactNode;
-    className?: string;
-}): import("react").JSX.Element;
-/** Declarative "render this to send the user to sign-in" (Clerk `<RedirectToSignIn>`). */
-export declare function RedirectToSignIn({ url, redirectUrl }: {
-    url?: string;
-    redirectUrl?: string;
-}): null;
-/** Declarative "render this to send the user to sign-up" (Clerk `<RedirectToSignUp>`). */
-export declare function RedirectToSignUp({ url, redirectUrl }: {
-    url?: string;
-    redirectUrl?: string;
-}): null;
-/**
- * §L1 (Clerk `<MultisessionAppSupport>`). Re-mounts its subtree whenever the
- * ACTIVE account changes, so per-user state held in component state or memo
- * caches is discarded on a `setActive({ session })` switch rather than bleeding
- * one account's data into the next. Keying on the session id (plus a stable key
- * while signed out) is the whole mechanism — React unmounts the old tree and
- * mounts a fresh one when the key changes.
- */
-export declare function MultisessionAppSupport({ children }: {
-    children: ReactNode;
-}): import("react").JSX.Element;
-/**
- * The signed-in user's avatar (image, or initials fallback) — the standalone
- * renderer `<UserButton>` uses internally, exported for reuse (Clerk `<UserAvatar>`).
- */
-export declare function UserAvatar({ size, className }: {
-    size?: number;
-    className?: string;
-}): import("react").JSX.Element | null;
-/**
- * §5.1 headless sign-up — the sign-up counterpart of {@link useSignIn}. Starts a
- * sign-up attempt and returns the resulting flow (usually `needs_email_verification`;
- * the shared `advance` then drives the code to completion), reloading the provider
- * when a sign-up completes with a session ticket.
- */
-export declare function useSignUp(): {
-    create: (input: {
-        email: string;
-        password: string;
-        fields?: Record<string, string>;
-        consent?: boolean;
-        captchaToken?: string;
-    }) => Promise<FlowState>;
-};
-export declare function OrganizationSwitcher(): import("react").JSX.Element;
-/**
- * Clerk-parity `useOrganizationList()`. The memberships the signed-in user
- * belongs to, plus a `createOrganization(name)` that creates one through FAPI and
- * re-boots the provider so the new membership appears everywhere. `memberships`
- * comes straight from {@link useOrganization} (the same list `<OrganizationSwitcher>`
- * renders), so there is one source of truth for what the user belongs to.
- */
-export declare function useOrganizationList(): {
-    memberships: ReturnType<typeof useOrganization>['memberships'];
-    createOrganization(name: string): Promise<{
-        id: string;
-        name: string;
-    } | null>;
-};
-/**
- * Clerk-parity `<CreateOrganization>`. A small name-and-submit form that creates
- * an organization via {@link useOrganizationList} and immediately makes it the
- * active org, so the user drops straight into the org they just made. Styled like
- * the `<SignUp>` card. `onCreate` fires with the created org for a caller that
- * wants to route afterwards.
- */
-export declare function CreateOrganization({ onCreate, }?: {
-    onCreate?(organization: {
-        id: string;
-        name: string;
-    }): void;
-}): import("react").JSX.Element;
-/**
- * Clerk-parity `<OrganizationList>`. Every organization the user belongs to as a
- * button that switches to it (mirroring `<OrganizationSwitcher>`'s markup), plus
- * an inline `<CreateOrganization>` so a user with no orgs — or who wants another —
- * can make one without leaving the list.
- */
-export declare function OrganizationList(): import("react").JSX.Element;
-/**
- * §2 The signed-in user's active devices, with per-device and "sign out everyone
- * else" revocation. A drop-in for a settings page — the composable half of the
- * post-login account surface an integrator needs the moment login is Atlas.
- */
-export declare function ActiveSessions(): import("react").JSX.Element;
-/**
- * §2 The signed-in user's profile — name (editable) and email addresses. Another
- * composable piece of the account surface; writes go to `PATCH /v1/client/me` and
- * re-boot the provider so the rest of the app sees the change.
- */
-export declare function ProfileCard(): import("react").JSX.Element | null;
-/**
- * §2 Manage two-factor authentication (authenticator app / TOTP). The full
- * enrollment ceremony — start (secret + otpauth URI), verify with a live code,
- * then the one-time backup codes — plus turn-off, in one composable drop-in, so a
- * team never rebuilds the FAPI dance to put 2FA in their own settings page. The
- * secret + `otpauth://` URI are shown for scan-or-manual entry (render a QR from
- * the URI if you like — kept dependency-free here).
- */
-export declare function ManageMfa(): import("react").JSX.Element;
-/**
- * §2 Manage passkeys (WebAuthn). Lists the user's registered credentials and runs
- * the full add ceremony — `POST /passkeys/begin` → `navigator.credentials.create`
- * (via the SDK's {@link createPasskey}) → `POST /passkeys/finish` — plus rename-free
- * removal, in one composable drop-in. Nothing renders the "Add" affordance when the
- * runtime has no WebAuthn support, so it degrades cleanly on older browsers.
- */
-export declare function ManagePasskeys(): import("react").JSX.Element;
-/**
- * §2 The drop-in post-login account surface. Composes the account-management
- * pieces (profile, 2FA, passkeys, devices). Each piece is also exported on its own
- * (`<ProfileCard/>`, `<ManageMfa/>`, `<ManagePasskeys/>`, `<ActiveSessions/>`) so a
- * team can drop just one into their existing settings page.
- */
-/**
- * §L3 extension API (Clerk `<UserProfile.Page>` / `<UserProfile.Link>`): add
- * your own tab of content, or an external link, into the prebuilt profile. Both
- * are descriptor components — `<UserProfile>` reads them from its children.
- */
-export interface ProfilePageProps {
-    /** The tab's label. */
-    label: ReactNode;
-    labelIcon?: ReactNode;
-    /** The tab's body. */
-    children?: ReactNode;
-}
-export interface ProfileLinkProps {
-    label: ReactNode;
-    labelIcon?: ReactNode;
-    /** Where the tab navigates instead of showing content. */
-    url: string;
-}
-/** A custom content tab inside `<UserProfile>`. Renders nothing on its own. */
-declare function UserProfilePage(_props: ProfilePageProps): null;
-/** A custom external-link tab inside `<UserProfile>`. Renders nothing on its own. */
-declare function UserProfileLink(_props: ProfileLinkProps): null;
-export declare function UserProfile({ children }?: {
-    children?: ReactNode;
-}): import("react").JSX.Element | null;
-export declare namespace UserProfile {
-    var Page: typeof UserProfilePage;
-    var Link: typeof UserProfileLink;
-}
-export declare function OrganizationProfile(): import("react").JSX.Element | null;
-/**
- * Clerk-parity `useWaitlist()`. Headless join: `join(email)` posts the address to
- * the waitlist endpoint and hands back the raw {@link FapiClient} response, so a
- * caller rendering its own form decides what to show on success vs. failure.
- */
-export declare function useWaitlist(): {
-    join: (email: string) => Promise<import("@atlasauth/js").FapiResponse<unknown>>;
-};
-/**
- * Clerk-parity `<Waitlist>`. An email-and-submit card (styled like `<SignUp>`)
- * that calls {@link useWaitlist}. A 200 swaps the form for a success message; any
- * other response surfaces the server's message as a field error, so a bad or
- * duplicate address is reported in place rather than silently swallowed.
- */
-export declare function Waitlist(): import("react").JSX.Element;
-/**
- * Clerk-parity `useReverification()`. A thin, headless wrapper over the EXISTING
- * step-up path (`@atlasauth/js`'s {@link reauthenticate} → `POST /v1/client/me/reauthenticate`)
- * — it invents no server endpoint.
+ * The implementations live in per-component sibling files (`sign-in.tsx`,
+ * `sign-up.tsx`, `user-button.tsx`, `organization.tsx`, `account.tsx`,
+ * `auth-buttons.tsx`, `control-components.tsx`, `billing.tsx`, `waitlist.tsx`,
+ * `reverification.tsx`, and the shared `flow.tsx` / `components-shared.tsx`).
+ * This module re-exports every one of them so the package's public API — what
+ * `index.ts` re-exports via `export * from './components'` — stays byte-for-byte
+ * identical after the split. Import sites (`@atlasauth/react`) are unaffected.
  *
- * Wrap a security-sensitive action with `withReverification(action)`. It runs the
- * action; if that throws or returns a `STEP_UP_REQUIRED` (reauthentication-required)
- * signal, it flips `needsReverification` true and parks the call. The caller renders
- * its own prompt, gathers a credential, and calls `completeReverification(input)`,
- * which re-authenticates in place and retries the action ONCE — resolving the
- * original `withReverification` promise with the retry's result. `cancelReverification`
- * abandons the parked call. A wrong password throws out of `completeReverification`
- * with the parked call intact, so the prompt can let the user try again.
- */
-export declare function useReverification(): {
-    withReverification<T>(action: () => T | Promise<T>): Promise<T>;
-    needsReverification: boolean;
-    completeReverification(input: ReauthInput): Promise<void>;
-    cancelReverification(): void;
-};
-/**
- * §commerce (Clerk commerce). A thin, HONEST SDK surface over the REAL
- * Stripe-backed billing API (`/v1/client/billing/*`): list plans, read the
- * subject's subscription, and start a Checkout Session or open the Billing
- * Portal — both of which the server issues as real Stripe-hosted URLs the
- * caller is redirected to. There is deliberately NO in-page card form: taking
- * card details would need a PCI-scoped Stripe Elements integration, and faking
- * one would be a lie. Redirect-to-Checkout is the same posture Stripe itself
- * recommends for most apps.
- */
-export interface CheckoutParams {
-    /** The plan to buy. */
-    planId: string;
-    /** Buy for an organization (its admin) rather than for the user. */
-    orgId?: string;
-    /** Where Stripe returns on success / cancel. Defaults to the current URL. */
-    successUrl?: string;
-    cancelUrl?: string;
-    /** Redirect to the Checkout URL (default true). False → the URL is only returned. */
-    redirect?: boolean;
-}
-/**
- * §commerce headless billing (Clerk `useCheckout`/subscription hooks combined).
- * Loads the instance's plans and — when signed in — the subject's subscription,
- * and exposes `checkout()` and `openPortal()`. Pass `{ orgId }` to operate on an
- * organization the user administers instead of on the user.
- */
-export declare function useBilling(opts?: {
-    orgId?: string;
-}): {
-    isLoaded: boolean;
-    plans: AtlasBillingPlan[];
-    subscription: AtlasBillingSubscription | null;
-    invoices: AtlasBillingInvoice[];
-    paymentMethod: AtlasPaymentMethod | null;
-    checkout: (params: CheckoutParams) => Promise<import("@atlasauth/js").FapiResponse<{
-        url: string;
-    }>>;
-    openPortal: (params?: {
-        returnUrl?: string;
-        orgId?: string;
-        redirect?: boolean;
-    }) => Promise<import("@atlasauth/js").FapiResponse<{
-        url: string;
-    }>>;
-    reload: () => Promise<void>;
-};
-/** §commerce Clerk-parity alias — just the `checkout` action from {@link useBilling}. */
-export declare function useCheckout(opts?: {
-    orgId?: string;
-}): {
-    checkout: (params: CheckoutParams) => Promise<import("@atlasauth/js").FapiResponse<{
-        url: string;
-    }>>;
-};
-/** §commerce Clerk-parity alias — the subject's subscription from {@link useBilling}. */
-export declare function useSubscription(opts?: {
-    orgId?: string;
-}): {
-    isLoaded: boolean;
-    subscription: AtlasBillingSubscription | null;
-    openPortal: (params?: {
-        returnUrl?: string;
-        orgId?: string;
-        redirect?: boolean;
-    }) => Promise<import("@atlasauth/js").FapiResponse<{
-        url: string;
-    }>>;
-    reload: () => Promise<void>;
-};
-/** §commerce Clerk-parity alias — the subject's invoices from {@link useBilling}. */
-export declare function useInvoices(opts?: {
-    orgId?: string;
-}): {
-    isLoaded: boolean;
-    invoices: AtlasBillingInvoice[];
-    reload: () => Promise<void>;
-};
-/** §commerce Clerk-parity alias — the subject's default payment method + Portal to change it. */
-export declare function usePaymentMethods(opts?: {
-    orgId?: string;
-}): {
-    isLoaded: boolean;
-    paymentMethod: AtlasPaymentMethod | null;
-    openPortal: (params?: {
-        returnUrl?: string;
-        orgId?: string;
-        redirect?: boolean;
-    }) => Promise<import("@atlasauth/js").FapiResponse<{
-        url: string;
-    }>>;
-    reload: () => Promise<void>;
-};
-/**
- * §commerce (Clerk `<PricingTable>`). Renders the instance's plans as cards with
- * price + features and a subscribe button that starts a real Stripe Checkout.
- * The plan the subject is currently on is marked as current (its button is
- * disabled and an "Manage billing" action opens the Billing Portal instead).
- */
-export declare function PricingTable({ orgId }?: {
-    orgId?: string;
-}): import("react").JSX.Element;
-/**
- * §commerce (Clerk `<Invoices>`). The subject's billing history — number, status,
- * amount, and a link to Stripe's hosted invoice / PDF. Renders nothing until
- * loaded, and an empty state when there are no invoices yet.
- */
-export declare function Invoices({ orgId }?: {
-    orgId?: string;
-}): import("react").JSX.Element;
-/**
- * §commerce (Clerk `<EmbeddedCheckout>`). In-page checkout for a plan: mounts
- * Stripe's own Embedded Checkout iframe — Stripe.js owns the card fields, so no
- * PCI-scoped data ever touches Atlas. Fetches the instance's Stripe publishable
- * key from `/billing/config`; when embedded checkout is not configured it renders
- * `fallback` (default: a hosted-redirect button) rather than a broken frame.
- */
-export declare function EmbeddedCheckout({ planId, orgId, returnUrl, fallback, }: {
-    planId: string;
-    orgId?: string;
-    /** Where Stripe returns after the in-page flow (defaults to the current URL). */
-    returnUrl?: string;
-    /** Rendered when embedded checkout is unavailable (no publishable key). */
-    fallback?: ReactNode;
-}): import("react").JSX.Element;
-export {};
+ * `<SignIn/>` and `<SignUp/>` are "full multi-step flows driven entirely by the
+ * server-side attempt status": no client here decides what comes next; each step
+ * renders whatever `status` the server returned, via the exhaustive mapping in
+ * @atlasauth/js. See `flow.tsx` for that shell.
+ */
+export { SignedIn, SignedOut, AtlasLoading, AtlasLoaded, Protect, MultisessionAppSupport, } from './control-components';
+export type { FlowProps } from './flow';
+export { SignIn, SocialSignInButton, useSignIn } from './sign-in';
+export { SignUp, useSignUp } from './sign-up';
+export type { MenuActionProps, MenuLinkProps } from './user-button';
+export { UserButton, UserAvatar } from './user-button';
+export type { AuthButtonProps } from './auth-buttons';
+export { SignInButton, SignUpButton, SignOutButton, RedirectToSignIn, RedirectToSignUp, } from './auth-buttons';
+export { OrganizationSwitcher, useOrganizationList, CreateOrganization, OrganizationList, OrganizationProfile, } from './organization';
+export type { ProfilePageProps, ProfileLinkProps } from './account';
+export { ActiveSessions, ProfileCard, ManageMfa, ManagePasskeys, UserProfile, } from './account';
+export { useWaitlist, Waitlist } from './waitlist';
+export { useReverification } from './reverification';
+export type { CheckoutParams } from './billing';
+export { useBilling, useCheckout, useSubscription, useInvoices, usePaymentMethods, PricingTable, Invoices, EmbeddedCheckout, } from './billing';