@seamless-auth/react 0.12.0 → 0.14.0

package/dist/client/createSeamlessAuthClient.d.ts

@@ -1,189 +0,0 @@
-import type { AddOrganizationMemberRequest, AuthenticatorAttachmentPolicy, CreateOrganizationRequest, CredentialUpdateResponse, LoginMethod as LoginMethodShape, LoginSuccessResponse, LogoutScope as LogoutScopeShape, MeResponse, MessageResponse, OAuthLoginSuccessResponse, OAuthProvidersResponse, OrganizationEnvelopeResponse, OrganizationListResponse, OrganizationMembersResponse, OrganizationMembershipEnvelopeResponse, OrganizationSwitchResponse, PublicOAuthProvider, PublicSystemConfigResponse, RegistrationRequest, StartOAuthLoginResponse, StepUpMethod as StepUpMethodShape, StepUpStatus as StepUpStatusShape, TotpEnrollmentStartResponse, TotpStatus as TotpStatusShape, UpdateOrganizationMemberRequest, UpdateOrganizationRequest } from '@seamless-auth/types';
-import { type SeamlessAuthResult } from './result';
-import { PasskeyPrfInput, PasskeyPrfResult } from './webauthnPrf';
-export interface SeamlessAuthClientOptions {
-    apiHost: string;
-    /**
-     * Default destination for `requestMagicLink()`. Every send from this client
-     * uses it unless a call passes its own, which keeps a resend on the same
-     * destination as the send it repeats. Omit it to keep the deployment's.
-     */
-    magicLinkRedirectUri?: string;
-}
-export interface LoginInput {
-    identifier: string;
-    passkeyAvailable: boolean;
-}
-export type LoginMethod = LoginMethodShape;
-/**
- * The login response minus its session material. The API returns a token and
- * subject here, which this SDK deliberately does not surface: sessions are
- * carried by cookies, so adopters have no reason to handle raw tokens.
- */
-export type LoginStartResult = Omit<LoginSuccessResponse, 'token' | 'sub'>;
-export type RegisterInput = RegistrationRequest;
-export interface PasskeyMetadata {
-    friendlyName: string;
-    platform: string;
-    browser: string;
-    deviceInfo: string;
-}
-export type CurrentUserResult = MeResponse;
-export type CreateOrganizationInput = CreateOrganizationRequest;
-export type UpdateOrganizationInput = UpdateOrganizationRequest;
-export type OrganizationMemberInput = AddOrganizationMemberRequest;
-export type OrganizationMemberUpdateInput = UpdateOrganizationMemberRequest;
-export type OrganizationsResult = OrganizationListResponse;
-export type OrganizationResult = OrganizationEnvelopeResponse;
-export type OrganizationMembersResult = OrganizationMembersResponse;
-/** Response body for a single membership mutation. */
-export type OrganizationMembershipResult = OrganizationMembershipEnvelopeResponse;
-/**
- * Response body when the active organization changes, minus its session
- * material. See `LoginStartResult` for why the token and subject are dropped.
- */
-export type OrganizationSwitchResult = Omit<OrganizationSwitchResponse, 'token' | 'sub' | 'sessionId'>;
-export type OAuthProvider = PublicOAuthProvider;
-export type OAuthProvidersResult = OAuthProvidersResponse;
-/**
- * The configuration a signed-out client may read. Fetched before there is a
- * session, so the sign-in screens can match how this instance is configured
- * instead of assuming a default set of methods.
- */
-export type PublicSystemConfigResult = PublicSystemConfigResponse;
-export interface StartOAuthLoginInput {
-    providerId: string;
-    redirectUri?: string;
-    returnTo?: string;
-}
-export type StartOAuthLoginResult = StartOAuthLoginResponse;
-export interface FinishOAuthLoginInput {
-    providerId: string;
-    code: string;
-    state: string;
-}
-/**
- * The completed OAuth response minus its session material, for the same reason
- * `LoginStartResult` drops it: sessions are carried by cookies.
- *
- * What this does surface is `returnTo`, the destination the caller asked for when it
- * started the flow. It comes back out of the state the auth server signed, so it is
- * the value that was validated against the configured origins at the start and not
- * one introduced at the callback. Absent when the caller asked for nothing, so treat
- * that as "use my own default" rather than as a failure.
- */
-export type FinishOAuthLoginResult = Omit<OAuthLoginSuccessResponse, 'token' | 'refreshToken' | 'sub'>;
-/** Response body for endpoints that only acknowledge the request. */
-export type MessageResult = MessageResponse;
-/** Payload returned by a completed passkey login. */
-export interface PasskeyLoginData {
-    prf?: PasskeyPrfResult;
-}
-/** Payload returned by a completed passkey registration. */
-export interface PasskeyRegistrationData {
-    credentialId: string;
-    prfCapable: boolean;
-}
-/** Response body returned when credential metadata is updated. */
-export type CredentialUpdateResult = CredentialUpdateResponse;
-/**
- * Which kind of authenticator to offer at registration. Omitting it leaves the
- * choice to the deployment's `authenticator_policy.attachment`, which offers
- * both kinds by default.
- *
- * Derived from the deployment policy type rather than restating its members:
- * `any` is a standing default a deployment sets, not something a single request
- * can ask for, so the request type is that policy minus that one member.
- */
-export type PasskeyAttachment = Exclude<AuthenticatorAttachmentPolicy, 'any'>;
-export interface RegisterPasskeyOptions {
-    metadata: PasskeyMetadata;
-    requestPrf?: boolean;
-    requirePrf?: boolean;
-    /**
-     * Narrows the browser picker to one kind of authenticator, for example
-     * `cross-platform` to send a user straight to an issued security key. A
-     * deployment that has pinned a different kind refuses this, so it is a
-     * request rather than an override.
-     */
-    attachment?: PasskeyAttachment;
-}
-export type StepUpMethod = StepUpMethodShape;
-export type TotpStatus = TotpStatusShape;
-export type TotpEnrollmentStartResult = TotpEnrollmentStartResponse;
-export type StepUpStatus = StepUpStatusShape;
-export interface PasskeyLoginOptions {
-    prf?: PasskeyPrfInput;
-}
-/** Step-up payload that also carries the PRF output for the caller. */
-export interface StepUpPrfData extends StepUpStatus {
-    credentialId: string;
-    prf: PasskeyPrfResult;
-}
-export type LogoutScope = LogoutScopeShape;
-export interface LogoutOptions {
-    scope?: LogoutScope;
-}
-/**
- * Headless auth client.
- *
- * Every request resolves to a `SeamlessAuthResult`: check `error` first, then
- * read `data`. Nothing here throws for an HTTP or transport failure.
- * `isPasskeyPrfSupported` is the one exception, since it is a local capability
- * check rather than a request.
- */
-export interface SeamlessAuthClient {
-    getCurrentUser: () => Promise<SeamlessAuthResult<CurrentUserResult>>;
-    login: (input: LoginInput) => Promise<SeamlessAuthResult<LoginStartResult>>;
-    loginWithPasskey: (options?: PasskeyLoginOptions) => Promise<SeamlessAuthResult<PasskeyLoginData>>;
-    logout: (options?: LogoutOptions) => Promise<SeamlessAuthResult<MessageResult>>;
-    logoutAllSessions: () => Promise<SeamlessAuthResult<MessageResult>>;
-    deleteUser: () => Promise<SeamlessAuthResult<MessageResult>>;
-    register: (input: RegisterInput) => Promise<SeamlessAuthResult<MessageResult>>;
-    requestPhoneOtp: () => Promise<SeamlessAuthResult<MessageResult>>;
-    verifyPhoneOtp: (verificationToken: string) => Promise<SeamlessAuthResult<MessageResult>>;
-    requestLoginPhoneOtp: () => Promise<SeamlessAuthResult<MessageResult>>;
-    verifyLoginPhoneOtp: (verificationToken: string) => Promise<SeamlessAuthResult<MessageResult>>;
-    requestEmailOtp: () => Promise<SeamlessAuthResult<MessageResult>>;
-    verifyEmailOtp: (verificationToken: string) => Promise<SeamlessAuthResult<MessageResult>>;
-    requestLoginEmailOtp: () => Promise<SeamlessAuthResult<MessageResult>>;
-    verifyLoginEmailOtp: (verificationToken: string) => Promise<SeamlessAuthResult<MessageResult>>;
-    /**
-     * @param redirectUri Where the emailed link should land. The deployment validates
-     * it against its configured origins and refuses anything else, so a tenant serving
-     * a web app and a mobile app can send each to its own destination. Omit it to fall
-     * back to the client's `magicLinkRedirectUri`, then to the deployment's own.
-     */
-    requestMagicLink: (redirectUri?: string) => Promise<SeamlessAuthResult<MessageResult>>;
-    checkMagicLink: () => Promise<SeamlessAuthResult<MessageResult>>;
-    verifyMagicLink: (token: string) => Promise<SeamlessAuthResult<MessageResult>>;
-    listOAuthProviders: () => Promise<SeamlessAuthResult<OAuthProvidersResult>>;
-    getPublicSystemConfig: () => Promise<SeamlessAuthResult<PublicSystemConfigResult>>;
-    startOAuthLogin: (input: StartOAuthLoginInput) => Promise<SeamlessAuthResult<StartOAuthLoginResult>>;
-    finishOAuthLogin: (input: FinishOAuthLoginInput) => Promise<SeamlessAuthResult<FinishOAuthLoginResult>>;
-    registerPasskey: (input: PasskeyMetadata | RegisterPasskeyOptions) => Promise<SeamlessAuthResult<PasskeyRegistrationData>>;
-    isPasskeyPrfSupported: () => Promise<boolean>;
-    getStepUpStatus: () => Promise<SeamlessAuthResult<StepUpStatus>>;
-    verifyStepUpWithPasskey: () => Promise<SeamlessAuthResult<StepUpStatus>>;
-    verifyStepUpWithPasskeyPrf: (input: PasskeyPrfInput) => Promise<SeamlessAuthResult<StepUpPrfData>>;
-    getTotpStatus: () => Promise<SeamlessAuthResult<TotpStatus>>;
-    startTotpEnrollment: () => Promise<SeamlessAuthResult<TotpEnrollmentStartResult>>;
-    verifyTotpEnrollment: (code: string) => Promise<SeamlessAuthResult<MessageResult>>;
-    disableTotp: (code: string) => Promise<SeamlessAuthResult<MessageResult>>;
-    verifyStepUpWithTotp: (code: string) => Promise<SeamlessAuthResult<StepUpStatus>>;
-    updateCredential: (input: {
-        id: string;
-        friendlyName: string | null;
-    }) => Promise<SeamlessAuthResult<CredentialUpdateResult>>;
-    deleteCredential: (id: string) => Promise<SeamlessAuthResult<MessageResult>>;
-    listOrganizations: () => Promise<SeamlessAuthResult<OrganizationsResult>>;
-    createOrganization: (input: CreateOrganizationInput) => Promise<SeamlessAuthResult<OrganizationResult>>;
-    getOrganization: (organizationId: string) => Promise<SeamlessAuthResult<OrganizationResult>>;
-    updateOrganization: (organizationId: string, input: UpdateOrganizationInput) => Promise<SeamlessAuthResult<OrganizationResult>>;
-    switchOrganization: (organizationId: string) => Promise<SeamlessAuthResult<OrganizationSwitchResult>>;
-    listOrganizationMembers: (organizationId: string) => Promise<SeamlessAuthResult<OrganizationMembersResult>>;
-    addOrganizationMember: (organizationId: string, input: OrganizationMemberInput) => Promise<SeamlessAuthResult<OrganizationMembershipResult>>;
-    updateOrganizationMember: (organizationId: string, userId: string, input: OrganizationMemberUpdateInput) => Promise<SeamlessAuthResult<OrganizationMembershipResult>>;
-    removeOrganizationMember: (organizationId: string, userId: string) => Promise<SeamlessAuthResult<MessageResult>>;
-}
-export declare const createSeamlessAuthClient: (opts: SeamlessAuthClientOptions) => SeamlessAuthClient;

package/dist/client/errors.d.ts

@@ -1,90 +0,0 @@
-import type { OAuthErrorCode as OAuthErrorCodeShape, WebAuthnErrorCode as WebAuthnErrorCodeShape } from '@seamless-auth/types';
-/**
- * Error carrying the auth server's response detail, so callers can map known
- * failures to their own messaging instead of only seeing a generic string.
- */
-export declare class SeamlessAuthError extends Error {
-    readonly status: number;
-    readonly body: unknown;
-    /**
-     * The underlying failure when the error was raised locally rather than by a
-     * response, for example the `DOMException` a WebAuthn ceremony throws.
-     */
-    readonly cause: unknown;
-    constructor(message: string, status: number, body?: unknown, cause?: unknown);
-}
-/**
- * Machine-readable codes the auth API returns alongside `error` on an OAuth
- * callback failure the user can act on.
- */
-export type OAuthErrorCode = OAuthErrorCodeShape;
-/**
- * Read the OAuth failure code off a result error. Returns `undefined` for
- * anything unrecognized, including codes added by a newer API, so callers keep
- * their generic messaging instead of showing a raw code.
- *
- * The auth API puts `code` at the top level of the error body, but a proxy in
- * front of it may normalize that body and nest the siblings of `error` under
- * `details`. Both locations are accepted so such a proxy does not silently
- * downgrade OAuth messaging to a generic failure.
- */
-export declare function getOAuthErrorCode(error: unknown): OAuthErrorCode | undefined;
-/**
- * Machine-readable codes registration is refused with when a deployment will not
- * enrol the authenticator on policy grounds.
- *
- * `attachment_not_allowed` comes from register/start with a `400`, before any
- * ceremony runs. The rest come from register/finish with a `403`, once the
- * credential exists and can be inspected.
- */
-export type PasskeyPolicyErrorCode = Exclude<WebAuthnErrorCodeShape, 'prf_output_not_allowed'>;
-/**
- * Read the passkey policy refusal off a registration error, from either stage of
- * the ceremony. Returns `undefined` for anything unrecognized, including codes
- * added by a newer API, so callers keep their generic messaging instead of
- * showing a raw code.
- *
- * The auth API sends the code as the whole of `error`, which is also what
- * becomes `error.message`. A proxy in front of it may instead derive a
- * human-readable `error` and keep the upstream body under `details`, so an
- * unrecognized top-level value falls through to the nested one rather than
- * ending the lookup.
- */
-export declare function getPasskeyPolicyErrorCode(error: unknown): PasskeyPolicyErrorCode | undefined;
-/**
- * Whether a failure means nobody is signed in.
- *
- * Enrollment takes the signed-in session, so a `401` there is an expired or missing
- * one rather than anything about the authenticator, and the two need different
- * messages: one asks the user to sign in again, the other to reach for a different
- * key. Raised locally, a ceremony failure carries `NETWORK_ERROR_STATUS`, so this
- * matches on the response status alone.
- */
-export declare function isUnauthenticated(error: unknown): boolean;
-/**
- * Detail recovered from a failed WebAuthn ceremony.
- *
- * `name` is the `DOMException` name, which is what distinguishes the cases a
- * user can act on: `NotAllowedError` for a dismissed prompt or no usable
- * credential, `SecurityError` for an origin or RP ID mismatch,
- * `InvalidStateError` for an already registered passkey. `code` is
- * SimpleWebAuthn's narrower reason when it identified one, for example
- * `ERROR_CEREMONY_ABORTED`.
- */
-export type WebAuthnErrorDetail = {
-    name: string;
-    code?: string;
-    message: string;
-};
-/**
- * Read the WebAuthn failure behind a result error. Returns `undefined` for
- * errors that did not come from a ceremony, so callers can branch on the
- * specific failure and otherwise fall back to `error.message`.
- */
-export declare function getWebAuthnErrorDetail(error: unknown): WebAuthnErrorDetail | undefined;
-/**
- * Build a `SeamlessAuthError` from a failed response, preserving the status and
- * the parsed body. The body may be empty or non-JSON, which is not treated as a
- * failure: the fallback message is used instead.
- */
-export declare function toSeamlessAuthError(response: Response, fallbackMessage: string): Promise<SeamlessAuthError>;

package/dist/client/result.d.ts

@@ -1,36 +0,0 @@
-import { SeamlessAuthError } from './errors';
-/**
- * Outcome of an auth request.
- *
- * Auth failures are expected outcomes rather than exceptions: a wrong OTP, an
- * expired magic link, or a disabled provider all map directly to UI state. So
- * requests resolve to a result instead of throwing, and `data` is only readable
- * once `error` has been checked.
- *
- * ```ts
- * const { data, error } = await authClient.getCurrentUser();
- * if (error) {
- *   setMessage(error.message);
- *   return;
- * }
- * setUser(data.user);
- * ```
- */
-export type SeamlessAuthResult<T> = {
-    data: T;
-    error: null;
-} | {
-    data: null;
-    error: SeamlessAuthError;
-};
-/** Status used when the request never reached the server. */
-export declare const NETWORK_ERROR_STATUS = 0;
-/**
- * Run a request and convert it into a result. Never throws for HTTP outcomes,
- * and also absorbs transport failures so callers only handle one shape.
- */
-export declare function requestResult<T>(request: Promise<Response>, fallbackMessage: string): Promise<SeamlessAuthResult<T>>;
-/** Wrap an already-derived value as a successful result. */
-export declare function resultOf<T>(data: T): SeamlessAuthResult<T>;
-/** Wrap a failure as a result. */
-export declare function resultError<T>(message: string, status?: number, body?: unknown, cause?: unknown): SeamlessAuthResult<T>;

package/dist/client/webauthnPrf.d.ts

@@ -1,27 +0,0 @@
-import { type AuthenticationResponseJSON, type PublicKeyCredentialRequestOptionsJSON } from '@simplewebauthn/browser';
-export type PasskeyPrfSalt = ArrayBuffer | ArrayBufferView | string;
-export interface PasskeyPrfInput {
-    salt: PasskeyPrfSalt;
-    secondSalt?: PasskeyPrfSalt;
-    credentialId?: string;
-}
-export interface PasskeyPrfResult {
-    credentialId: string;
-    output: Uint8Array;
-    outputBase64url: string;
-}
-export declare function encodePrfSalt(salt: PasskeyPrfSalt): string;
-export declare function createPrfRequestBody(input: PasskeyPrfInput): {
-    prf: {
-        secondSalt?: string | undefined;
-        salt: string;
-    };
-    credentialId?: string | undefined;
-};
-export declare function isPasskeyPrfSupported(): Promise<boolean>;
-export declare function preparePrfRequestOptions(optionsJSON: PublicKeyCredentialRequestOptionsJSON): PublicKeyCredentialRequestOptionsJSON;
-export declare function extractPasskeyPrfResult(credential: AuthenticationResponseJSON): PasskeyPrfResult | null;
-export declare function stripPrfResultsFromAssertion(credential: AuthenticationResponseJSON): AuthenticationResponseJSON;
-export declare function getRegistrationPrfCapable(attestationResponse: {
-    clientExtensionResults?: unknown;
-}): boolean;

package/dist/client/webauthnSupport.d.ts

@@ -1,10 +0,0 @@
-/**
- * True when the browser exposes a usable WebAuthn API in a secure context.
- * This is the coarse gate for any passkey flow, including PRF assertions.
- */
-export declare function isWebAuthnAvailable(): boolean;
-/**
- * True when a user-verifying platform authenticator (Touch ID, Windows Hello,
- * and similar) can be used on this device.
- */
-export declare function isPlatformAuthenticatorAvailable(): Promise<boolean>;

package/dist/fetchWithAuth.d.ts

@@ -1,5 +0,0 @@
-interface FetchWithAuthOptions {
-    authHost?: string;
-}
-export declare const createFetchWithAuth: (opts: FetchWithAuthOptions) => (input: string, init?: RequestInit) => Promise<Response>;
-export {};

package/dist/scopedRoles.d.ts

@@ -1,2 +0,0 @@
-export declare function roleGrantsAccess(grantedRole: string, requiredRole: string): boolean;
-export declare function hasScopedRole(grantedRoles: unknown, requiredRoles: string | string[]): boolean;

package/dist/session/createAuthSession.d.ts

@@ -1,61 +0,0 @@
-import { CurrentUserResult, FinishOAuthLoginInput, FinishOAuthLoginResult, LoginStartResult, MessageResult, OAuthProvidersResult, OrganizationSwitchResult, PasskeyLoginData, PasskeyMetadata, PasskeyRegistrationData, RegisterPasskeyOptions, StartOAuthLoginInput, StartOAuthLoginResult, StepUpPrfData, StepUpStatus } from '../client/createSeamlessAuthClient';
-import type { SeamlessAuthResult } from '../client/result';
-import { PasskeyPrfInput } from '../client/webauthnPrf';
-import { Credential, Organization, User } from '../types';
-import { SessionStoragePort } from './storage';
-/** Everything a UI binding renders from. Replaced wholesale on every change. */
-export interface AuthSessionState {
-    user: User | null;
-    credentials: Credential[];
-    organizations: Organization[];
-    activeOrganization: Organization | null;
-    stepUpStatus: StepUpStatus | null;
-    isAuthenticated: boolean;
-    loading: boolean;
-    hasSignedInBefore: boolean;
-}
-export interface AuthSessionActions {
-    login: (identifier: string, passkeyAvailable: boolean) => Promise<SeamlessAuthResult<LoginStartResult>>;
-    handlePasskeyLogin: () => Promise<SeamlessAuthResult<PasskeyLoginData>>;
-    registerPasskey: (input: PasskeyMetadata | RegisterPasskeyOptions) => Promise<SeamlessAuthResult<PasskeyRegistrationData>>;
-    refreshSession: () => Promise<SeamlessAuthResult<CurrentUserResult>>;
-    logout: () => Promise<SeamlessAuthResult<MessageResult>>;
-    logoutAllSessions: () => Promise<SeamlessAuthResult<MessageResult>>;
-    deleteUser: () => Promise<SeamlessAuthResult<MessageResult>>;
-    updateCredential: (credential: Credential) => Promise<SeamlessAuthResult<Credential>>;
-    deleteCredential: (credentialId: string) => Promise<SeamlessAuthResult<MessageResult>>;
-    switchOrganization: (organizationId: string) => Promise<SeamlessAuthResult<OrganizationSwitchResult>>;
-    listOAuthProviders: () => Promise<SeamlessAuthResult<OAuthProvidersResult>>;
-    startOAuthLogin: (input: StartOAuthLoginInput) => Promise<SeamlessAuthResult<StartOAuthLoginResult>>;
-    finishOAuthLogin: (input: FinishOAuthLoginInput) => Promise<SeamlessAuthResult<FinishOAuthLoginResult>>;
-    refreshStepUpStatus: () => Promise<SeamlessAuthResult<StepUpStatus>>;
-    verifyStepUpWithPasskey: () => Promise<SeamlessAuthResult<StepUpStatus>>;
-    verifyStepUpWithPasskeyPrf: (input: PasskeyPrfInput) => Promise<SeamlessAuthResult<StepUpPrfData>>;
-    verifyStepUpWithTotp: (code: string) => Promise<SeamlessAuthResult<StepUpStatus>>;
-    hasRole: (role: string) => boolean | undefined;
-    hasScopedRole: (role: string | string[]) => boolean | undefined;
-    markSignedIn: () => void;
-}
-/**
- * Framework-agnostic session store.
- *
- * `getState` and `subscribe` are the shape React's `useSyncExternalStore` wants,
- * and they adapt directly to a Vue ref or an Angular observable, so bindings stay
- * thin instead of each reimplementing this state machine.
- */
-export interface AuthSession {
-    getState: () => AuthSessionState;
-    subscribe: (listener: () => void) => () => void;
-    actions: AuthSessionActions;
-    destroy: () => void;
-}
-export interface AuthSessionOptions {
-    apiHost: string;
-    storage?: SessionStoragePort;
-    /**
-     * When false, a previous sign-in is still recorded but never surfaced, so a UI
-     * cannot branch on it.
-     */
-    detectPreviousSignIn?: boolean;
-}
-export declare function createAuthSession(options: AuthSessionOptions): AuthSession;

package/dist/session/storage.d.ts

@@ -1,17 +0,0 @@
-/**
- * The session store's only browser dependency, expressed as a port so the store
- * itself stays framework and environment agnostic. Implementations never throw:
- * private browsing and disabled storage are normal, and neither is a reason to
- * fail an auth flow.
- */
-export interface SessionStoragePort {
-    get(key: string): string | null;
-    set(key: string, value: string): void;
-}
-export declare function createMemoryStorage(): SessionStoragePort;
-export declare function createBrowserStorage(): SessionStoragePort;
-/**
- * Browser storage where there is a `localStorage`, memory otherwise. The memory
- * fallback is what keeps the store usable during server-side rendering.
- */
-export declare function createDefaultStorage(): SessionStoragePort;

package/dist/types.d.ts

@@ -1,5 +0,0 @@
-import type { CredentialResponse, MeUser, Organization as OrganizationShape, OrganizationMembership as OrganizationMembershipShape } from '@seamless-auth/types';
-export type User = MeUser;
-export type OrganizationMembership = OrganizationMembershipShape;
-export type Organization = OrganizationShape;
-export type Credential = CredentialResponse;