@react-vault/create-app 0.1.0

package/templates/tanstack-query/.claude/skills/axios-auth/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: axios-auth
+description: Configure the project's axios instance and set the auth token ONCE at login via setAuthToken() — not per-request. Used by TanStack Query service methods. Covers response interceptor for notifications + 401 redirect. Use when the user mentions axios, API client, set token, login flow, 401 handling, response interceptor, error notification.
+---
+
+# Axios + Auth Pattern (TanStack variant)
+
+The HTTP layer is two files under `src/api/` plus the auth-token helper from `@<scope>/core/http`. Tokens are set ONCE at login on the axios instance — not injected per-request via interceptor.
+
+## File map
+
+| File                       | Role                                                                               |
+| -------------------------- | ---------------------------------------------------------------------------------- |
+| `src/api/axiosInstance.ts` | Single shared `AxiosInstance` from `createAxios()`                                 |
+| `src/api/http.ts`          | Typed `GET<TRes,TParams>` / `POST<TRes,TReq>` / `PUT` / `PATCH` / `DELETE` helpers |
+| `@<scope>/core/http`       | Exports `createAxios`, `setAuthToken`, `clearAuthToken`, `ApiError`                |
+
+## Workflow
+
+### Step 1 — Set token at login (the canonical place)
+
+Inside your login service's success path:
+
+```ts
+import { useMutation } from '@tanstack/react-query';
+import { setAuthToken } from '@<scope>/core/http';
+import axiosInstance from '@/api/axiosInstance';
+import { loginService } from '@/services/auth';
+
+const loginMutation = useMutation({
+  mutationFn: loginService,
+  onSuccess: (response) => {
+    setAuthToken(axiosInstance, response.token);
+    // navigate to dashboard, etc.
+  },
+});
+```
+
+`setAuthToken` writes to `instance.defaults.headers.common.Authorization`. Every subsequent request carries the header automatically.
+
+### Step 2 — Clear on logout / 401
+
+`createAxios()` wires this: when a response is 401, it auto-calls `clearAuthToken(instance)` then invokes the `onUnauthorized` callback (which redirects to `/login` in the scaffolded template).
+
+Manual logout flow:
+
+```ts
+import { clearAuthToken } from '@<scope>/core/http';
+import axiosInstance from '@/api/axiosInstance';
+import { useQueryClient } from '@tanstack/react-query';
+
+const queryClient = useQueryClient();
+
+function logout() {
+  clearAuthToken(axiosInstance);
+  queryClient.clear(); // wipe all cached server data
+  navigate('/login');
+}
+```
+
+`queryClient.clear()` matters on logout — without it, a re-login sees stale data for a flash before refetch.
+
+### Step 3 — Use the typed HTTP helpers in services
+
+```ts
+// src/services/kyc.ts
+import { GET, POST } from '@/api/http';
+
+export interface IKycRequest {
+  pan: string;
+  aadhaar: string;
+}
+export interface IKycResponse {
+  id: string;
+  status: 'pending' | 'approved' | 'rejected';
+}
+
+export const submitKyc = (payload: IKycRequest): Promise<IKycResponse> =>
+  POST<IKycResponse, IKycRequest>('/kyc', payload);
+
+export const getKyc = (id: string): Promise<IKycResponse> => GET<IKycResponse>(`/kyc/${id}`);
+```
+
+Services are pure async functions — no hooks, no React. That makes them trivially unit-testable.
+
+## Conventions enforced
+
+- ❌ NEVER inject token via a `request.use` interceptor — use `setAuthToken` at login.
+- ❌ NEVER read token from `localStorage` on every request.
+- ❌ NEVER hardcode `Authorization: Bearer ...` anywhere.
+- ❌ NEVER use plain `axios.get(...)` in service files — use the typed `GET<TRes,TParams>` helper.
+- ✅ One axios instance per app — exported as the default from `axiosInstance.ts`.
+- ✅ All services use typed helpers from `src/api/http.ts`.
+- ✅ On logout: `clearAuthToken()` + `queryClient.clear()`.
+
+## Quick reference checklist
+
+When adding API auth:
+
+- [ ] Login mutation calls `setAuthToken(axiosInstance, token)` in `onSuccess`
+- [ ] Logout calls `clearAuthToken(axiosInstance)` AND `queryClient.clear()`
+- [ ] Token never appears in `localStorage` (memory only)
+- [ ] `onUnauthorized` callback in `axiosInstance.ts` redirects to `/login`
+
+## References
+
+- [`references/full-code-walkthrough.md`](references/full-code-walkthrough.md) — annotated walk through axiosInstance + http helpers
+- [`references/error-shape.md`](references/error-shape.md) — `ApiError` contract + safe surfacing inside `useMutation`/`useQuery`
+- [`references/notification-pattern.md`](references/notification-pattern.md) — toast notifications from mutation `onSuccess`/`onError` callbacks

package/templates/tanstack-query/.claude/skills/axios-auth/references/error-shape.md

@@ -0,0 +1,89 @@
+# Error shape contract (TanStack variant)
+
+## `ApiError` (from `@<scope>/core/http`)
+
+```ts
+class ApiError extends Error {
+  readonly kind: ApiErrorKind;
+  readonly status?: number;
+  readonly ref?: string;
+  readonly fieldErrors?: Record<string, string>;
+}
+
+type ApiErrorKind =
+  | 'network'
+  | 'timeout'
+  | 'unauthorized'
+  | 'forbidden'
+  | 'not_found'
+  | 'conflict'
+  | 'validation'
+  | 'rate_limited'
+  | 'server_error'
+  | 'cancelled'
+  | 'unknown';
+```
+
+`createAxios` converts every axios error into `ApiError`. Services THROW it (since they return promises). TanStack Query catches and exposes via `useQuery({ error })` / `useMutation({ onError, error })`.
+
+## Backend error envelope
+
+```json
+{
+  "errors": [{ "detail": "Email is already taken" }]
+}
+```
+
+Or for field-level (422):
+
+```json
+{
+  "errors": {
+    "email": ["is already taken"],
+    "password": ["is too short"]
+  }
+}
+```
+
+`ApiError.fieldErrors` is populated for `kind === 'validation'`.
+
+## Surfacing errors in components
+
+```tsx
+import { useMutation } from '@tanstack/react-query';
+import type { ApiError } from '@<scope>/core/http';
+import { submitKyc } from '@/services/kyc';
+
+const mutation = useMutation({
+  mutationFn: submitKyc,
+  onError: (error: ApiError) => {
+    if (error.kind === 'validation' && error.fieldErrors) {
+      // Set RHF field errors:
+      for (const [field, msg] of Object.entries(error.fieldErrors)) {
+        form.setError(field as keyof FormValues, { message: msg });
+      }
+    } else if (error.kind === 'unauthorized') {
+      // Already handled by axios's onUnauthorized — nothing to do.
+    } else {
+      toast.error(safeMessage(error));
+    }
+  },
+});
+```
+
+## NEVER expose to UI
+
+- ❌ `error.message` from raw axios — leaks "Network Error" / stack info
+- ❌ `error.response.data.errors` raw — may contain SQL fragments, DB IDs
+- ❌ HTTP status codes as user copy ("Error 500")
+
+Use `toSafeView(error, t)` from `@<scope>/core/compliance` to convert `ApiError.kind` into a user-facing toast title + description + ref code.
+
+## Retry semantics
+
+Default `queryClient` config (in `src/api/queryClient.ts`):
+
+- Queries: retry up to 2x on 5xx and 408/429; never retry 4xx (except 408/429); no retry on network errors that aren't transient
+- Mutations: NEVER auto-retry. Use idempotency-key + explicit user-triggered retry
+
+This matters in BFSI: silently retrying a payment mutation on an ambiguous 5xx could double-charge.

package/templates/tanstack-query/.claude/skills/axios-auth/references/full-code-walkthrough.md

@@ -0,0 +1,121 @@
+# Axios + Auth — full code walkthrough (TanStack)
+
+## `src/api/axiosInstance.ts`
+
+```ts
+import { createAxios } from '@<scope>/core/http';
+import { env } from '../env.js';
+
+const axiosInstance = createAxios({
+  baseURL: env.VITE_API_BASE_URL,
+  timeoutMs: env.VITE_API_TIMEOUT_MS,
+  authHeaderName: env.VITE_AUTH_HEADER_NAME,
+  snakeCaseBackend: false,
+  onUnauthorized: () => {
+    if (typeof window !== 'undefined') {
+      window.location.href = '/login';
+    }
+  },
+});
+
+export default axiosInstance;
+```
+
+Key points:
+
+- `createAxios` attaches BFSI-grade interceptors: request-IDs, idempotency keys, error mapping to typed `ApiError`.
+- `onUnauthorized` fires AFTER `clearAuthToken` has wiped the token off the instance.
+- `snakeCaseBackend: true` enables automatic snake↔camel transformation.
+
+Unlike the RTK variant, there is NO separate `interceptor.ts` file — the response side is handled by `createAxios` (error mapping) and by mutation/query callbacks (notifications). No side-effect import needed.
+
+## `src/api/http.ts`
+
+```ts
+import type { AxiosRequestConfig } from 'axios';
+import axiosInstance from './axiosInstance.js';
+
+export async function GET<TResponse, TParams = void>(
+  url: string,
+  params?: TParams,
+  config?: AxiosRequestConfig,
+): Promise<TResponse> {
+  const { data } = await axiosInstance.get<TResponse>(url, { ...config, params });
+  return data;
+}
+
+export async function POST<TResponse, TRequest = void>(
+  url: string,
+  payload?: TRequest,
+  config?: AxiosRequestConfig,
+): Promise<TResponse> {
+  const { data } = await axiosInstance.post<TResponse>(url, payload, config);
+  return data;
+}
+
+// PUT, PATCH, DELETE follow the same pattern
+```
+
+Key points:
+
+- All helpers unwrap `response.data` — services return the body, not the AxiosResponse envelope.
+- Generic `<TResponse, TRequest>` keeps the call-site type-safe without forcing the caller to cast.
+- Optional `config` lets you pass `headers`, `responseType`, `signal` (AbortController), etc. per-call.
+
+## Why no `baseQuery` here
+
+TanStack Query doesn't have RTK Query's "baseQuery" abstraction — service functions ARE the baseQuery equivalent. Each service is a tiny async function that throws on failure. `useQuery`/`useMutation` calls them and handles their promise.
+
+## File upload pattern
+
+```ts
+export const uploadDocument = (file: File): Promise<IDocumentRecord> => {
+  const form = new FormData();
+  form.append('file', file);
+  return POST<IDocumentRecord, FormData>('/docs/upload', form, {
+    headers: { 'Content-Type': 'multipart/form-data' },
+  });
+};
+```
+
+## File download pattern
+
+```ts
+export const downloadStatement = (id: string): Promise<Blob> =>
+  GET<Blob, void>(`/statements/${id}`, undefined, { responseType: 'blob' });
+```
+
+Then in the component:
+
+```tsx
+const { data: blob } = useQuery({
+  queryKey: ['statement', id],
+  queryFn: () => downloadStatement(id),
+  enabled: shouldDownload,
+});
+
+useEffect(() => {
+  if (!blob) return;
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = `statement-${id}.pdf`;
+  a.click();
+  URL.revokeObjectURL(url);
+}, [blob, id]);
+```
+
+## Cancellation pattern
+
+```ts
+// In the component:
+const controller = new AbortController();
+const { data } = useQuery({
+  queryKey: ['search', term],
+  queryFn: () => GET<ISearchResult>('/search', { q: term }, { signal: controller.signal }),
+});
+// On unmount or term change:
+useEffect(() => () => controller.abort(), []);
+```
+
+TanStack Query also auto-cancels stale in-flight queries when the queryKey changes — usually you don't need explicit AbortController.

package/templates/tanstack-query/.claude/skills/axios-auth/references/notification-pattern.md

@@ -0,0 +1,109 @@
+# Notification pattern (TanStack variant)
+
+Unlike the RTK variant (notifications dispatched from baseQuery via Redux slice), TanStack lets you dispatch notifications directly from mutation callbacks. No global slice needed.
+
+## Simple — at the call site
+
+```tsx
+import { useMutation } from '@tanstack/react-query';
+import { toast } from 'sonner';
+import { submitKyc } from '@/services/kyc';
+import type { ApiError } from '@<scope>/core/http';
+
+const mutation = useMutation({
+  mutationFn: submitKyc,
+  onSuccess: () => toast.success('KYC submitted'),
+  onError: (err: ApiError) => toast.error(safeMessage(err)),
+});
+```
+
+## DRY — wrap mutation creation
+
+When most mutations want the same toast behaviour:
+
+```ts
+// src/services/useAuditedMutation.ts
+import { useMutation, type UseMutationOptions } from '@tanstack/react-query';
+import { toast } from 'sonner';
+import type { ApiError } from '@<scope>/core/http';
+
+export function useAuditedMutation<TData, TVars>(
+  options: UseMutationOptions<TData, ApiError, TVars> & {
+    successMessage?: string;
+    eventName: string; // audit event (e.g. 'kyc.submission.attempted')
+  },
+) {
+  return useMutation({
+    ...options,
+    onMutate: async (vars) => {
+      // emit audit event (see bfsi-audit-action skill for full pattern)
+      await options.onMutate?.(vars);
+    },
+    onSuccess: (data, vars, ctx) => {
+      if (options.successMessage) toast.success(options.successMessage);
+      options.onSuccess?.(data, vars, ctx);
+    },
+    onError: (err, vars, ctx) => {
+      toast.error(safeMessage(err));
+      options.onError?.(err, vars, ctx);
+    },
+  });
+}
+```
+
+Then use it everywhere:
+
+```tsx
+const submit = useAuditedMutation({
+  mutationFn: submitKyc,
+  successMessage: 'KYC submitted',
+  eventName: 'kyc.submission.attempted',
+  onSuccess: () => navigate('/kyc/success'),
+});
+```
+
+## Global error handler
+
+For a true catch-all, set a `QueryCache` / `MutationCache` error handler in the `QueryClient` config:
+
+```ts
+import { QueryClient, QueryCache, MutationCache } from '@tanstack/react-query';
+import { toast } from 'sonner';
+
+export const queryClient = new QueryClient({
+  queryCache: new QueryCache({
+    onError: (error) => {
+      // ONLY fire for unhandled errors — usually you want per-component handling
+      // toast.error(safeMessage(error as ApiError));
+    },
+  }),
+  mutationCache: new MutationCache({
+    onError: (error, _vars, _ctx, mutation) => {
+      // Skip if the mutation has its own onError
+      if (mutation.options.onError) return;
+      toast.error(safeMessage(error as ApiError));
+    },
+  }),
+  // ... defaultOptions
+});
+```
+
+The `MutationCache.onError` pattern is useful: every mutation that doesn't define its own `onError` gets the default toast.
+
+## Avoid: toast spam
+
+❌ Don't toast on every query error — components are often mounted in the background or with stale flags, and you'd toast for non-user-initiated fetches.
+
+✅ DO toast on every mutation error — mutations are user-initiated, so an error means the user's action failed.
+
+## Avoid: notifications for 401 / cancelled
+
+The 401 path already redirects to login (handled by `createAxios.onUnauthorized`). Don't double-toast. Filter inside `safeMessage`:
+
+```ts
+function safeMessage(error: ApiError): string {
+  if (error.kind === 'unauthorized') return ''; // empty = no toast (sonner handles)
+  if (error.kind === 'cancelled') return '';
+  return toSafeView(error, t).description;
+}
+```

package/templates/tanstack-query/.claude/skills/constants-organization/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: constants-organization
+description: Where each kind of constant lives in the project and how to add a new one. Covers URL endpoint constants, HTTP method usage, route paths, queryKey conventions, validation regex patterns, and app-wide constants. Use when adding a new endpoint URL, route path, queryKey, validation regex, or any other shared constant.
+---
+
+# Constants Organisation (TanStack variant)
+
+Constants are split across files by purpose. Each kind has one home — don't scatter.
+
+## File map
+
+```
+src/utils/constants/
+├── appConstants.ts       App-wide enums (ERROR / SUCCESS, storage keys, etc.)
+├── urlConstants.ts       Every API endpoint URL string
+├── routeConstants.ts     Every router path
+├── queryKeys.ts          TanStack Query queryKey factories
+└── regexConstants.ts     Reusable validation regex
+```
+
+## When to use which
+
+| Adding …                     | Goes in             | Naming convention                                   |
+| ---------------------------- | ------------------- | --------------------------------------------------- |
+| A backend endpoint URL       | `urlConstants.ts`   | `<FEATURE>_URLS.<ACTION>` or `<FEATURE>_URL`        |
+| A frontend route path        | `routeConstants.ts` | `ROUTES.<feature>.<view>`                           |
+| A TanStack queryKey          | `queryKeys.ts`      | `<feature>Keys.list()` / `<feature>Keys.detail(id)` |
+| A validation regex           | `regexConstants.ts` | `<FIELD>_REGEX`                                     |
+| A storage key                | `appConstants.ts`   | `<PURPOSE>_KEY`                                     |
+| An enum value used > 1 place | `appConstants.ts`   | `<NAME>` (UPPER_SNAKE)                              |
+
+## Workflow — adding a new endpoint
+
+1. Open `src/utils/constants/urlConstants.ts`.
+2. Add to the appropriate feature block (or create one):
+   ```ts
+   export const KYC_URLS = {
+     LIST: '/kyc',
+     DETAIL: (id: string) => `/kyc/${id}`,
+     SUBMIT: '/kyc/submit',
+   } as const;
+   ```
+3. Reference from the feature's service:
+
+   ```ts
+   import { KYC_URLS } from '@/utils/constants/urlConstants';
+   import { GET } from '@/api/http';
+
+   export const getKycList = () => GET<IKycListResponse>(KYC_URLS.LIST);
+   ```
+
+## Workflow — adding a queryKey
+
+TanStack Query queryKeys are arrays that uniquely identify cached data. Always go through a queryKey factory — never inline the array. This keeps invalidation patterns DRY and refactor-safe.
+
+`src/utils/constants/queryKeys.ts`:
+
+```ts
+export const kycKeys = {
+  all: ['kyc'] as const,
+  lists: () => [...kycKeys.all, 'list'] as const,
+  list: (filters?: KycFilters) => [...kycKeys.lists(), filters] as const,
+  details: () => [...kycKeys.all, 'detail'] as const,
+  detail: (id: string) => [...kycKeys.details(), id] as const,
+};
+```
+
+Usage:
+
+```tsx
+// Component
+const { data } = useQuery({
+  queryKey: kycKeys.list(filters),
+  queryFn: () => getKycList(filters),
+});
+
+// Invalidation
+queryClient.invalidateQueries({ queryKey: kycKeys.all }); // all KYC
+queryClient.invalidateQueries({ queryKey: kycKeys.lists() }); // all lists
+queryClient.invalidateQueries({ queryKey: kycKeys.detail(id) }); // one record
+```
+
+See [`references/query-key-factories.md`](references/query-key-factories.md) for the full pattern + invalidation matrix.
+
+## Workflow — adding a route
+
+1. Open `src/utils/constants/routeConstants.ts`.
+2. Add the path:
+   ```ts
+   export const ROUTES = {
+     kyc: {
+       list: '/kyc',
+       detail: '/kyc/:id',
+       submit: '/kyc/submit',
+     },
+   } as const;
+   ```
+3. Wire it in `src/routes/index.tsx`:
+   ```tsx
+   <Route
+     path={ROUTES.kyc.list}
+     element={
+       <ProtectedRoute permission="kyc.view">
+         <KycList />
+       </ProtectedRoute>
+     }
+   />
+   ```
+
+## Workflow — adding a validation regex
+
+Centralise — never inline.
+
+```ts
+// src/utils/constants/regexConstants.ts
+export { PII_PATTERNS } from '@<scope>/core/pii';
+import { PII_PATTERNS } from '@<scope>/core/pii';
+
+export const PAN_REGEX = PII_PATTERNS.pan;
+export const AADHAAR_REGEX = PII_PATTERNS.aadhaar;
+export const MOBILE_REGEX = PII_PATTERNS.mobileIndia;
+export const IFSC_REGEX = PII_PATTERNS.ifsc;
+```
+
+Use in Zod:
+
+```ts
+import { PAN_REGEX } from '@/utils/constants/regexConstants';
+const schema = z.object({ pan: z.string().regex(PAN_REGEX) });
+```
+
+## Conventions enforced
+
+- ❌ NEVER hardcode a URL string in a service — always reference `urlConstants.ts`.
+- ❌ NEVER inline a queryKey array — always use a key factory from `queryKeys.ts`.
+- ❌ NEVER inline a regex in component code or schema — always via `regexConstants.ts`.
+- ✅ Group by feature within each constants file (e.g. `KYC_URLS`, `LOAN_URLS`; `kycKeys`, `loanKeys`).
+- ✅ Use `as const` on the exported objects so TypeScript infers literal types.
+- ✅ Functions for dynamic paths (`DETAIL: (id) => ...`), strings for static ones.
+
+## References
+
+- [`references/example-files.md`](references/example-files.md) — full templates for each constants file
+- [`references/query-key-factories.md`](references/query-key-factories.md) — queryKey factory pattern + invalidation matrix

package/templates/tanstack-query/.claude/skills/constants-organization/references/example-files.md

@@ -0,0 +1,111 @@
+# Constants files — templates (TanStack)
+
+## `src/utils/constants/appConstants.ts`
+
+```ts
+// Storage keys
+export const SELECTED_LOCALE = 'selectedLocale';
+export const THEME_PREFERENCE = 'themePreference';
+
+// Notification types
+export const SUCCESS = 'success' as const;
+export const ERROR = 'error' as const;
+export const INFO = 'info' as const;
+export const WARNING = 'warning' as const;
+
+// Status enums
+export const KYC_STATUS = {
+  PENDING: 'pending',
+  APPROVED: 'approved',
+  REJECTED: 'rejected',
+  REVIEW: 'review',
+} as const;
+export type KycStatus = (typeof KYC_STATUS)[keyof typeof KYC_STATUS];
+```
+
+## `src/utils/constants/urlConstants.ts`
+
+```ts
+export const AUTH_URLS = {
+  LOGIN: '/auth/login',
+  LOGOUT: '/auth/logout',
+  REFRESH: '/auth/refresh',
+  PROFILE: '/auth/profile',
+} as const;
+
+export const KYC_URLS = {
+  LIST: '/kyc',
+  DETAIL: (id: string) => `/kyc/${id}`,
+  SUBMIT: '/kyc/submit',
+  APPROVE: (id: string) => `/kyc/${id}/approve`,
+} as const;
+```
+
+## `src/utils/constants/routeConstants.ts`
+
+```ts
+export const ROUTES = {
+  home: '/',
+  login: '/login',
+  dashboard: '/dashboard',
+  kyc: { list: '/kyc', detail: '/kyc/:id', submit: '/kyc/submit' },
+  notFound: '*',
+} as const;
+
+export const kycDetailPath = (id: string): string => `/kyc/${id}`;
+```
+
+## `src/utils/constants/queryKeys.ts`
+
+```ts
+// One factory per feature. Each factory exports a const object with:
+//   - `all`: top-level scope
+//   - `lists()` / `list(filters)`: list queries (filters in key for cache isolation)
+//   - `details()` / `detail(id)`: detail queries (id in key)
+//   - Other entity-specific keys
+
+export const kycKeys = {
+  all: ['kyc'] as const,
+  lists: () => [...kycKeys.all, 'list'] as const,
+  list: (filters?: KycFilters) => [...kycKeys.lists(), filters] as const,
+  details: () => [...kycKeys.all, 'detail'] as const,
+  detail: (id: string) => [...kycKeys.details(), id] as const,
+};
+
+export const transactionKeys = {
+  all: ['transactions'] as const,
+  lists: () => [...transactionKeys.all, 'list'] as const,
+  list: (filters?: TxFilters) => [...transactionKeys.lists(), filters] as const,
+  details: () => [...transactionKeys.all, 'detail'] as const,
+  detail: (id: string) => [...transactionKeys.details(), id] as const,
+  byAccount: (accountId: string) => [...transactionKeys.all, 'byAccount', accountId] as const,
+};
+
+interface KycFilters {
+  status?: string;
+  page?: number;
+}
+interface TxFilters {
+  dateFrom?: string;
+  dateTo?: string;
+  type?: string;
+}
+```
+
+## `src/utils/constants/regexConstants.ts`
+
+```ts
+export { PII_PATTERNS } from '@<scope>/core/pii';
+import { PII_PATTERNS } from '@<scope>/core/pii';
+
+export const PAN_REGEX = PII_PATTERNS.pan;
+export const AADHAAR_REGEX = PII_PATTERNS.aadhaar;
+export const MOBILE_REGEX = PII_PATTERNS.mobileIndia;
+export const IFSC_REGEX = PII_PATTERNS.ifsc;
+export const PINCODE_REGEX = PII_PATTERNS.pincodeIndia;
+export const EMAIL_REGEX = PII_PATTERNS.email;
+
+// App-specific patterns:
+export const REFERENCE_CODE_REGEX = /^ERR-[A-Z0-9]{4}$/;
+export const TRANSACTION_ID_REGEX = /^TXN[0-9]{12}$/;
+```