@oxy.so/services 1.0.0

package/src/ui/components/authChooser/requestSurfaces.tsx

@@ -0,0 +1,128 @@
+/**
+ * The PRIMARY visual of an active "Sign in with Oxy" request — one surface per
+ * route, chosen by {@link RequestPrimarySurface} from the controller's own facts.
+ *
+ * Each is a leading visual and nothing else: the status sentence underneath is
+ * owned by `signInProgressLabel`, and the alternatives by `TroubleDisclosure`.
+ * That separation is what keeps exactly one primary action on screen (issue
+ * #691) — a surface here can never grow a competing button.
+ *
+ * Anti-phishing: the QR plate encodes `signIn.qrPayload` and renders NOTHING
+ * derived from it. Application identity, origin, and scopes are resolved
+ * server-side by the approver (Commons), never read out of the payload here.
+ */
+
+import type React from 'react';
+import { ActivityIndicator, View } from 'react-native';
+import MaterialCommunityIcons from '../../icons/MaterialCommunityIcons';
+import QRCode from 'react-native-qrcode-svg';
+import { Button } from '@oxy.so/bloom/button';
+import { useTheme } from '@oxy.so/bloom/theme';
+import { Text } from '@oxy.so/bloom/typography';
+import type { CommonsDeliveryRoute, SignInProgress } from '@oxy.so/core';
+import { authChooserStyles as styles } from './styles';
+import type { Theme, Translate } from './types';
+
+/** High-contrast QR colors — intentionally fixed (NOT themed) for scan reliability. */
+const QR_PLATE_BG = '#FFFFFF';
+const QR_FOREGROUND = '#000000';
+const QR_SIZE = 196;
+/** The leading route glyph, sized to sit where the QR plate otherwise would. */
+const ROUTE_GLYPH_SIZE = 44;
+
+/**
+ * The indeterminate leading visual: the request exists but has nothing to show yet.
+ * Uses RN's ActivityIndicator — `@oxy.so/bloom/loading` can tree-shake to `undefined`
+ * in rolldown-vite production bundles when co-imported with `@oxy.so/bloom/button`
+ * (auth.oxy.so/authorize blank screen, React #130).
+ */
+export const PreparingSurface: React.FC = () => {
+  const theme = useTheme();
+  return <ActivityIndicator size="large" color={theme.colors.primary} />;
+};
+
+/** The leading glyph for a route whose surface is elsewhere (the phone, Commons). */
+export const RouteGlyph: React.FC<{
+  name: keyof typeof MaterialCommunityIcons.glyphMap;
+  color: string;
+}> = ({ name, color }) => (
+  <MaterialCommunityIcons name={name} size={ROUTE_GLYPH_SIZE} color={color} />
+);
+
+/** The cross-device handoff: a headline over the fixed-contrast QR plate. */
+export const QrPlate: React.FC<{ payload: string; theme: Theme; t: Translate }> = ({
+  payload,
+  theme,
+  t,
+}) => (
+  <>
+    <Text style={[styles.qrHeadline, { color: theme.colors.text }]}>
+      {t('accountSwitcher.qrHeadline')}
+    </Text>
+    <View style={styles.qrPlate}>
+      <QRCode value={payload} size={QR_SIZE} backgroundColor={QR_PLATE_BG} color={QR_FOREGROUND} />
+    </View>
+  </>
+);
+
+/**
+ * The acquisition surface. For someone with no Commons at all this is the
+ * GENUINE primary route, not a fallback — a same-device QR they would have to
+ * scan with the very screen showing it is a dead end — so it renders as the
+ * surface's one primary action.
+ */
+export const GetCommonsPrompt: React.FC<{
+  theme: Theme;
+  t: Translate;
+  onGetCommons: () => void;
+}> = ({ theme, t, onGetCommons }) => (
+  <>
+    <Text style={[styles.mutedText, { color: theme.colors.textSecondary }]}>
+      {t('accountSwitcher.commonsNotInstalled')}
+    </Text>
+    <Button
+      variant="primary"
+      onPress={onGetCommons}
+      style={styles.primaryButton}
+      testID="get-commons-button"
+    >
+      {t('accountSwitcher.getCommons')}
+    </Button>
+  </>
+);
+
+/**
+ * The one primary visual for the request's current state.
+ *
+ * Ordered most-terminal-first, so a late-arriving route can never pull the
+ * surface back from "confirming" to a QR the user has already scanned. Every
+ * branch reads only the facts it is handed — there is no local timeline, and no
+ * dependency on WHICH kind of request produced them (the account dialog's device
+ * flow and the IdP's OAuth-bound lane both resolve the same three).
+ */
+export const RequestPrimarySurface: React.FC<{
+  route: CommonsDeliveryRoute | null;
+  progress: SignInProgress;
+  qrPayload: string | null;
+  theme: Theme;
+  t: Translate;
+}> = ({ route, progress, qrPayload, theme, t }) => {
+  if (progress === 'identity-confirmed') {
+    return <RouteGlyph name="check-circle" color={theme.colors.success} />;
+  }
+  if (progress === 'confirming-identity') {
+    return <PreparingSurface />;
+  }
+  if (route === 'qr' && qrPayload) {
+    return <QrPlate payload={qrPayload} theme={theme} t={t} />;
+  }
+  if (route === 'await-push') {
+    return <RouteGlyph name="cellphone-message" color={theme.colors.primary} />;
+  }
+  if (route === 'open-commons') {
+    return <RouteGlyph name="open-in-app" color={theme.colors.primary} />;
+  }
+  // No route resolved yet (or a route with no payload to render): the request is
+  // being prepared. Honest, and the only state that is not route-specific.
+  return <PreparingSurface />;
+};

package/src/ui/components/authChooser/signInProgress.ts

@@ -0,0 +1,58 @@
+/**
+ * The sign-in status line's copy (issue #691, Phase 5).
+ *
+ * One responsibility: map the controller's DERIVED `signIn.progress` — plus the
+ * chosen route, which only disambiguates the generic waiting step — onto a
+ * sentence. Pure and total, with no clock and no state of its own: the line can
+ * therefore only advance when the controller observed a real signal, never on a
+ * timer and never optimistically.
+ *
+ * The ladder the user sees:
+ *
+ *     Preparing request
+ *     Check Commons on your phone
+ *     Opened in Commons
+ *     Confirming identity
+ *     Identity confirmed
+ */
+
+import type { CommonsDeliveryRoute, SignInProgress } from '@oxy.so/core';
+import type { Translate } from './types';
+
+/**
+ * The status sentence for the active request, or `null` when there is nothing
+ * honest to say (no live request, or a terminal error — which is toasted, never
+ * rendered inline).
+ */
+export function signInProgressLabel(
+  progress: SignInProgress,
+  route: CommonsDeliveryRoute | null,
+  t: Translate,
+): string | null {
+  switch (progress) {
+    case 'idle':
+      return null;
+    case 'preparing':
+      return t('accountSwitcher.progress.preparing');
+    case 'awaiting-approval':
+      // The only step whose copy depends on the route: waiting means something
+      // different when the user is holding a QR than when Commons was opened
+      // for them. `await-push` never reaches here — a chosen push route is
+      // itself a confirmed dispatch, so it derives to `delivered-to-commons`.
+      if (route === 'qr') return t('accountSwitcher.progress.scanWithCommons');
+      if (route === 'open-commons') return t('accountSwitcher.progress.continueInCommons');
+      return t('accountSwitcher.progress.awaitingApproval');
+    case 'delivered-to-commons':
+      return t('accountSwitcher.progress.checkCommons');
+    case 'opened-in-commons':
+      return t('accountSwitcher.progress.openedInCommons');
+    case 'confirming-identity':
+      return t('accountSwitcher.progress.confirming');
+    case 'identity-confirmed':
+      return t('accountSwitcher.progress.confirmed');
+    default: {
+      const _exhaustive: never = progress;
+      return _exhaustive;
+    }
+  }
+}

package/src/ui/components/authChooser/styles.ts

@@ -0,0 +1,213 @@
+import { StyleSheet } from 'react-native';
+
+/** High-contrast QR plate background — kept in sync with `OxyAuthChooser`'s QR colors. */
+const QR_PLATE_BG = '#FFFFFF';
+
+/**
+ * Shared styles for `OxyAuthChooser`'s views. Extracted from `OxyAccountDialogScreen`
+ * so both the Dialog-wrapped host and any bare host (e.g. a future
+ * auth.oxy.so hub page) render identically without duplicating a StyleSheet.
+ *
+ * Only what NativeWind cannot express lives here: the animated collapse, the
+ * fixed-contrast QR plate, per-account accent rings, and the small subordinate
+ * text-link rhythm every view's fallback affordances share.
+ */
+export const authChooserStyles = StyleSheet.create({
+  rows: {
+    width: '100%',
+    gap: 8,
+  },
+  accountRow: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    gap: 12,
+    borderWidth: StyleSheet.hairlineWidth,
+    borderRadius: 16,
+    paddingVertical: 10,
+    paddingHorizontal: 12,
+  },
+  rowDisabled: {
+    opacity: 0.6,
+  },
+  avatarRing: {
+    borderRadius: 9999,
+    borderWidth: 2,
+    padding: 1,
+  },
+  rowMeta: {
+    flex: 1,
+    minWidth: 0,
+  },
+  rowName: {
+    fontSize: 15,
+    fontWeight: '600',
+  },
+  rowHandle: {
+    fontSize: 12.5,
+    marginTop: 1,
+  },
+  /**
+   * Animated-collapse container for the account switch list — the outer clip and
+   * the inner measuring wrapper. Style-based (NOT NativeWind): the container
+   * carries the animated `height`/`opacity` off a reanimated style, and the
+   * measuring wrapper must stay className-free so its `onLayout` fires on RN-Web.
+   */
+  collapse: {
+    overflow: 'hidden',
+  },
+  collapseMeasure: {
+    width: '100%',
+  },
+  /**
+   * The HERO block that opens the account menu: the current account's large
+   * avatar, a greeting, and the "Manage your Oxy account" pill — centred and
+   * deliberately chrome-free (no card, no grouped-section surface) so the
+   * grouped cards below read as the menu proper. The account's email sits above
+   * it in the Dialog's own nav bar, not here.
+   */
+  hero: {
+    alignItems: 'center',
+    paddingTop: 4,
+    paddingBottom: 20,
+    gap: 12,
+  },
+  /**
+   * The current account's accent ring in the switch list, drawn OUTSIDE its
+   * avatar as an overlay so it adds no width to the row — every avatar in the
+   * list keeps the same footprint and the same content line. The 3px offset is
+   * the ring's 2px stroke plus a 1px gap.
+   */
+  currentAvatarRing: {
+    position: 'absolute',
+    top: -3,
+    left: -3,
+    right: -3,
+    bottom: -3,
+    borderWidth: 2,
+    borderRadius: 9999,
+  },
+  /**
+   * The hero avatar's pressable wrapper — the "change your photo" entry point.
+   * `relative` so the accent ring + camera badge (both absolutely positioned)
+   * anchor to the avatar box.
+   */
+  heroAvatarPressable: {
+    position: 'relative',
+  },
+  /** The hero avatar's accent ring — an overlay, like the row-level one. */
+  heroAvatarRing: {
+    position: 'absolute',
+    top: -4,
+    left: -4,
+    right: -4,
+    bottom: -4,
+    borderWidth: 3,
+    borderRadius: 9999,
+  },
+  /** Greeting + address stacked tight, centred (the hero's own 12px gap sits
+   *  between this block and the avatar / manage pill, not between these lines). */
+  heroNameBlock: {
+    alignItems: 'center',
+    gap: 2,
+  },
+  heroGreeting: {
+    fontSize: 22,
+    fontWeight: '600',
+    textAlign: 'center',
+  },
+  /** The account address (`username@oxy.so` / `@handle`) under the greeting. */
+  heroAddress: {
+    fontSize: 14,
+    textAlign: 'center',
+  },
+  /**
+   * The switch row's disclosure affordance — a filled circle around the chevron,
+   * right-aligned to the same 12px row inset every other trailing element uses.
+   */
+  chevronCircle: {
+    width: 32,
+    height: 32,
+    borderRadius: 16,
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  footerLink: {
+    alignSelf: 'center',
+    paddingVertical: 10,
+    marginTop: 12,
+  },
+  linkText: {
+    fontSize: 14,
+    fontWeight: '600',
+  },
+  signInBlock: {
+    width: '100%',
+  },
+  primaryButton: {
+    width: '100%',
+    borderRadius: 14,
+    marginTop: 8,
+  },
+  secondaryButton: {
+    width: '100%',
+    borderRadius: 14,
+    marginTop: 10,
+  },
+  usernameInput: {
+    width: '100%',
+    borderWidth: StyleSheet.hairlineWidth,
+    borderRadius: 14,
+    paddingVertical: 12,
+    paddingHorizontal: 14,
+    fontSize: 16,
+    marginTop: 8,
+  },
+  dividerRow: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    width: '100%',
+    marginVertical: 14,
+  },
+  dividerLine: {
+    flex: 1,
+    height: StyleSheet.hairlineWidth,
+  },
+  dividerText: {
+    marginHorizontal: 12,
+    fontSize: 13,
+  },
+  centeredBlock: {
+    alignItems: 'center',
+    justifyContent: 'center',
+    gap: 12,
+    paddingVertical: 24,
+  },
+  mutedText: {
+    fontSize: 14,
+    textAlign: 'center',
+  },
+  qrHeadline: {
+    fontSize: 16,
+    fontWeight: '700',
+    textAlign: 'center',
+  },
+  qrPlate: {
+    padding: 16,
+    borderRadius: 16,
+    backgroundColor: QR_PLATE_BG,
+  },
+  /**
+   * The revealed "Having trouble?" alternatives — a tight stack of subordinate
+   * text links. They share `footerLink`'s rhythm, so the stack itself only has
+   * to stop them drifting apart.
+   */
+  troubleActions: {
+    width: '100%',
+    alignItems: 'center',
+  },
+  /** The disclosure trigger, aligned with the subordinate links it reveals. */
+  troubleTrigger: {
+    alignSelf: 'center',
+    marginTop: 12,
+  },
+});

package/src/ui/components/authChooser/types.ts

@@ -0,0 +1,159 @@
+/**
+ * Shared types + per-account color resolution for the auth chooser's views.
+ *
+ * One responsibility: the vocabulary every view module in this folder speaks
+ * (theme/translate aliases, the container-supplied action bundles, and the
+ * account accent). No JSX, no state, no I/O — so a view can import it without
+ * dragging any other view in.
+ */
+
+import { APP_COLOR_NAMES, APP_COLOR_PRESETS, type AppColorName, type useTheme } from '@oxy.so/bloom/theme';
+import type { useI18n } from '../../hooks/useI18n';
+
+export type Theme = ReturnType<typeof useTheme>;
+export type Translate = ReturnType<typeof useI18n>['t'];
+
+/**
+ * One SUBORDINATE action on a sign-in surface — an alternative revealed behind
+ * "Having trouble?", or a non-competing link under the primary.
+ *
+ * Never a primary button: a sign-in surface presents exactly ONE of those (issue
+ * #691), and keeping every other affordance on this single shape is what stops
+ * one of them quietly growing into a co-equal button again.
+ *
+ * Part of the public SDK surface — `OxySignInRequestSurface` takes these.
+ */
+export interface OxySignInSurfaceAction {
+  /** Stable identity for the list, and the action's `testID`. */
+  key: string;
+  /** Already-localized label. The host resolves its own copy. */
+  label: string;
+  onPress: () => void;
+  disabled?: boolean;
+}
+
+/** The account-row actions the container wires for the switcher + menu views. */
+export interface OxyAuthChooserHandlers {
+  /**
+   * Become one `principal acting as account` pair.
+   *
+   * A `contextId`, never an `accountId`: on a device holding two people the
+   * same organization is reachable through both, and an account id cannot name
+   * which person's route to take.
+   */
+  onActivate: (contextId: string) => void;
+  /**
+   * Drop ONE pair. The same account reached through somebody else stays — that
+   * is a different session with a different audit actor.
+   */
+  onRemoveContext: (contextId: string) => void;
+  /** Drop ONE PERSON and every account they reach here, and nobody else's. */
+  onRemovePrincipal: (principalId: string) => void;
+  onAdd: () => void;
+  onManage: () => void;
+  /**
+   * Change the current account's photo — opens the avatar-change flow. Because
+   * the account menu lives in the AccountDialog surface, this MORPHS that surface
+   * into `ChangeAvatar` (via `openAvatarPicker` → `openWithinOrPresent`), the same
+   * flow ManageAccount's avatar uses; it never stacks a new dialog.
+   */
+  onEditAvatar: () => void;
+}
+
+/**
+ * The account menu's HERO block — the current account, rendered large.
+ *
+ * Built by the container from `useOxy().user`, not from a directory row, and
+ * that asymmetry is deliberate rather than an oversight: the directory carries
+ * the minimum that renders a row (name, handle, avatar) for EVERY person on the
+ * device, while the account this client is actually signed in as is the one it
+ * legitimately holds a full profile for — so the hero keeps its real email and
+ * its own accent colour, and the rows below it do not pretend to.
+ */
+export interface AccountHeroModel {
+  displayName: string;
+  /** The canonical `@oxy.so` email when there is one, else the `@handle`. */
+  addressLine: string | null;
+  avatarUrl: string | undefined;
+  /** The account's own Bloom accent, resolved to a hex. */
+  accentHex: string;
+}
+
+/** Used/total storage bytes for the "Oxy storage" block, or `null` when unknown. */
+export interface AccountStorageModel {
+  usedBytes: number;
+  limitBytes: number;
+}
+
+/** The account-menu row actions the container wires (deep-links / sheets / sign-out). */
+export interface AccountsMenuActions {
+  onOpenSettings: () => void;
+  onOpenData: () => void;
+  onManageStorage: () => void;
+  onUpgradeStorage: () => void;
+  onHelp: () => void;
+  onPrivacy: () => void;
+  onTerms: () => void;
+  onSignOut: () => void;
+  customItems: readonly {
+    key: string;
+    label: string;
+    icon?: string;
+    onPress: () => void;
+  }[];
+}
+
+/**
+ * Where a WebAuthn ceremony can run from the current origin.
+ *
+ * A credential minted for `oxy.so` can only be ASSERTED there (or a loopback
+ * dev host) — a hard, browser-enforced RP-ID boundary, not feature detection.
+ * `'direct'` = a first-party Oxy web origin, the ceremony runs here.
+ * `'hub'`    = any other web origin; it runs in the auth.oxy.so popup instead.
+ * `'none'`   = native, where Commons owns identity.
+ */
+export type PasskeyMode = 'direct' | 'hub' | 'none';
+
+/**
+ * Everything that is NOT the sign-in surface's one primary action.
+ *
+ * The container wires these once; each view decides which of them are genuine
+ * alternatives to ITS primary surface and hands those to `TroubleDisclosure`
+ * (issue #691: fallbacks stay hidden until the user asks or the primary route
+ * fails). A view never renders one of these as a button.
+ */
+export interface SignInAlternatives {
+  /** Whether a WebAuthn ceremony is reachable from this origin at all. */
+  passkeyAvailable: boolean;
+  /**
+   * `true` while a DIRECT ceremony is in flight. The hub-popup variant reports
+   * its progress through `snapshot.signIn` instead, so it never sets this.
+   */
+  passkeyPending: boolean;
+  onSignInWithPasskey: () => void;
+  /** Fall back to the cross-device QR handoff (restarts the request). */
+  onShowQr: () => void;
+  /** Open the Commons store listing / landing page for this platform. */
+  onGetCommons: () => void;
+  /** Enter the account-creation view. */
+  onCreateAccount: () => void;
+}
+
+/**
+ * Resolve an account's stored color (a named Bloom preset, e.g. `'purple'`) to
+ * a concrete brand hex for the row accent. Falls back to the theme primary when
+ * the account has no color or the value is not a recognized preset, so the accent
+ * renders in EVERY consumer regardless of NativeWind availability.
+ */
+export function resolveAccentHex(color: string | null, fallback: string): string {
+  const preset = toPreset(color);
+  return preset ? APP_COLOR_PRESETS[preset].hex : fallback;
+}
+
+/** Narrow a stored color string to a known `AppColorName`, or `undefined`. */
+export function toPreset(color: string | null): AppColorName | undefined {
+  if (!color) return undefined;
+  return (APP_COLOR_NAMES as readonly string[]).includes(color)
+    ? (color as AppColorName)
+    : undefined;
+}

package/src/ui/components/authChooser/useUsernameAvailability.ts

@@ -0,0 +1,60 @@
+/**
+ * Debounced username-availability check over the existing SDK method.
+ *
+ * One responsibility: turn keystrokes into an `idle | checking | available |
+ * taken` verdict without racing. A sequence guard drops superseded responses,
+ * and a NETWORK failure resets the (now stale) verdict and toasts — it never
+ * paints an inline error inside the dialog (owner mandate).
+ */
+
+import { useCallback, useRef, useState } from 'react';
+import { toast } from '@oxy.so/bloom/toast';
+import type { OxyServices } from '@oxy.so/core';
+import type { Translate } from './types';
+
+export type UsernameStatus = 'idle' | 'checking' | 'available' | 'taken';
+
+/** Keystrokes settle for this long before a check is issued. */
+const DEBOUNCE_MS = 400;
+/** Shorter than this and there is nothing worth asking the server about. */
+const MIN_USERNAME_LENGTH = 3;
+
+export function useUsernameAvailability(
+  oxyServices: OxyServices,
+  t: Translate,
+): {
+  status: UsernameStatus;
+  check: (value: string) => void;
+} {
+  const [status, setStatus] = useState<UsernameStatus>('idle');
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const requestSeqRef = useRef(0);
+
+  const check = useCallback(
+    (value: string) => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+      const seq = ++requestSeqRef.current;
+      if (!value || value.length < MIN_USERNAME_LENGTH) {
+        setStatus('idle');
+        return;
+      }
+      setStatus('checking');
+      timerRef.current = setTimeout(() => {
+        void oxyServices
+          .checkUsernameAvailability(value)
+          .then((result) => {
+            if (seq !== requestSeqRef.current) return; // superseded by a newer check
+            setStatus(result.available ? 'available' : 'taken');
+          })
+          .catch(() => {
+            if (seq !== requestSeqRef.current) return;
+            setStatus('idle');
+            toast.error(t('accounts.create.username.checkFailed'));
+          });
+      }, DEBOUNCE_MS);
+    },
+    [oxyServices, t],
+  );
+
+  return { status, check };
+}

package/src/ui/components/feedback/constants.ts

@@ -0,0 +1,22 @@
+import type { FeedbackType, PriorityLevel } from './types';
+
+export const FEEDBACK_TYPES: FeedbackType[] = [
+    { id: 'bug', label: 'Bug Report', icon: 'bug', color: '#FF3B30', description: 'Report a problem or issue' },
+    { id: 'feature', label: 'Feature Request', icon: 'bulb', color: '#007AFF', description: 'Suggest a new feature' },
+    { id: 'general', label: 'General Feedback', icon: 'chatbubble', color: '#34C759', description: 'Share your thoughts' },
+    { id: 'support', label: 'Support Request', icon: 'help-circle', color: '#FF9500', description: 'Get help with something' },
+];
+
+export const PRIORITY_LEVELS: PriorityLevel[] = [
+    { id: 'low', label: 'Low', icon: 'arrow-down', color: '#34C759' },
+    { id: 'medium', label: 'Medium', icon: 'remove', color: '#FF9500' },
+    { id: 'high', label: 'High', icon: 'arrow-up', color: '#FF3B30' },
+    { id: 'critical', label: 'Critical', icon: 'warning', color: '#FF0000' },
+];
+
+export const CATEGORIES: Record<string, string[]> = {
+    bug: ['UI/UX', 'Performance', 'Authentication', 'File Management', 'Billing', 'Other'],
+    feature: ['User Interface', 'File Management', 'Security', 'Performance', 'Integration', 'Other'],
+    general: ['User Experience', 'Design', 'Performance', 'Documentation', 'Other'],
+    support: ['Account Issues', 'Billing', 'Technical Problems', 'Feature Questions', 'Other'],
+};

package/src/ui/components/feedback/types.ts

@@ -0,0 +1,52 @@
+import type { Animated } from 'react-native';
+
+export interface FeedbackData {
+    type: 'bug' | 'feature' | 'general' | 'support';
+    title: string;
+    description: string;
+    priority: 'low' | 'medium' | 'high' | 'critical';
+    category: string;
+    contactEmail: string;
+    systemInfo: boolean;
+}
+
+export interface FeedbackState {
+    status: 'idle' | 'submitting' | 'success' | 'error';
+    message: string;
+}
+
+export interface FeedbackType {
+    id: FeedbackData['type'];
+    label: string;
+    icon: string;
+    color: string;
+    description: string;
+}
+
+export interface PriorityLevel {
+    id: FeedbackData['priority'];
+    label: string;
+    icon: string;
+    color: string;
+}
+
+export interface FeedbackColors {
+    primary: string;
+    text: string;
+    secondaryText: string;
+    border: string;
+    background: string;
+    inputBackground: string;
+    success?: string;
+}
+
+export interface FeedbackStepAnimations {
+    fadeAnim: Animated.Value;
+    slideAnim: Animated.Value;
+}
+
+export interface User {
+    id?: string;
+    email?: string;
+    username?: string;
+}