spaps-sdk 1.6.1 → 1.6.3

package/README.md

@@ -1,444 +1,228 @@
----
-id: spaps-typescript-sdk
-title: spaps TypeScript SDK
-category: sdk
-tags:
-  - sdk
-  - typescript
-  - client
-ai_summary: |
-  Reference for the spaps TypeScript SDK covering configuration, admin helpers,
-  and examples for interacting with authentication, payments, and permission
-  APIs from JavaScript or TypeScript applications.
-last_updated: 2025-02-14
----
+# spaps-sdk
 
-# @spaps/sdk
+TypeScript SDK for the Sweet Potato Authentication & Payment Service.
 
-<a href="https://www.npmjs.com/package/spaps-sdk"><img alt="npm" src="https://img.shields.io/npm/v/spaps-sdk.svg"></a>
-<img alt="node" src="https://img.shields.io/badge/node-%3E%3D14-brightgreen">
-<img alt="types" src="https://img.shields.io/badge/types-TypeScript-blue">
+## TL;DR
 
-> Sweet Potato Authentication & Payment Service SDK
+**The Problem**: SPAPS consumers need one client that can speak auth, payments, secure messaging, issue reporting, entitlements, and dayrate APIs without rebuilding request plumbing for every app.
 
-Zero-config client for SPAPS authentication, payments, and permission checking. Works automatically with local development mode.
+**The Solution**: `spaps-sdk` exposes a typed `SPAPSClient` with source-backed namespaces for the major SPAPS surfaces and a small set of permission helpers for app code.
 
-## 🔐 New in v1.1.0: Admin API Methods!
+### Why Use `spaps-sdk`?
 
-Built-in admin API methods for Stripe product management:
+| Feature | What It Does |
+| --- | --- |
+| Zero-config local mode | Point at `localhost` and the SDK automatically treats it as local mode |
+| Typed namespaces | Use `auth`, `payments`, `sessions`, `secureMessages`, `issueReporting`, `email`, `entitlements`, `dayrate`, `cfo`, and `admin` from one client |
+| Browser and server key support | Configure with `publishableKey`, `secretKey`, or the legacy `apiKey` field |
+| Shared contracts | Re-exports many `spaps-types` definitions so apps can stay on one dependency surface |
 
-```typescript
-import { SPAPSClient } from 'spaps-sdk';
+## Metadata
 
-const spaps = new SPAPSClient({
-  apiKey: 'your-api-key',
-  apiUrl: 'https://api.sweetpotato.dev'
-});
-
-// Authenticate as admin
-await spaps.signIn('admin@example.com', 'password');
-
-// Admin API methods
-await spaps.admin.createProduct({
-  name: 'Premium Plan',
-  category: 'subscription',
-  description: 'Advanced features'
-});
+- `package_name`: `spaps-sdk`
+- `latest_version`: `1.6.2`
+- `minimum_runtime`: `Node.js >=14.0.0`
+- `api_base_url`: `https://api.sweetpotato.dev`
 
-await spaps.admin.updateProduct('prod_123', {
-  name: 'Premium Plan Pro'
-});
+## Installation
 
-await spaps.admin.createPrice({
-  product_id: 'prod_123',
-  unit_amount: 2999,
-  currency: 'usd',
-  interval: 'month'
-});
+### npm
 
-// Super admin operations
-await spaps.admin.syncProducts();
+```bash
+npm install spaps-sdk
 ```
 
-## 🔐 Permission Utilities
-
-Built-in permission checking and role-based access control:
+### pnpm
 
-```typescript
-import { isAdminAccount, canAccessAdmin, getUserRole } from 'spaps-sdk';
-
-// Check admin status
-const isAdmin = isAdminAccount('buildooor@gmail.com'); // true
-
-// Check admin access with detailed result
-const adminCheck = canAccessAdmin(user);
-if (adminCheck.allowed) {
-  // Show admin UI
-}
-
-// Get user role
-const role = getUserRole('user@example.com'); // 'user' | 'admin' | 'guest'
-
-// Check if authenticated user is admin
-if (spaps.isAdmin(currentUser)) {
-  // Show admin features
-}
+```bash
+pnpm add spaps-sdk
 ```
 
-See [PERMISSIONS.md](./PERMISSIONS.md) for React examples and complete documentation.
-
-## Installation
+### yarn
 
 ```bash
-npm install spaps-sdk
-# or
 yarn add spaps-sdk
-# or
-pnpm add spaps-sdk
 ```
 
-### Compatibility
-
-- ✅ **Node.js**: Fully supported (v14+) with automatic fetch polyfill
-- ✅ **Browser**: Works in all modern browsers  
-- ✅ **TypeScript**: Full type definitions included
-- ✅ **Next.js**: Server and client components supported
-- ✅ **React Native**: Compatible with proper setup
-
-The SDK automatically includes a `cross-fetch` polyfill for Node.js environments that don't have native fetch support.
-
-## Quick Start
+## Quick Example
 
-```javascript
+```typescript
 import { SPAPSClient } from 'spaps-sdk';
-// or
-const { SPAPSClient } = require('spaps-sdk');
 
-// Auto-detects local mode - no API key needed for localhost!
 const spaps = new SPAPSClient({
-  apiUrl: 'http://localhost:3301' // Optional, auto-detected
+  apiUrl: 'http://localhost:3301',
 });
 
-// Login
 const { data } = await spaps.login('user@example.com', 'password');
 console.log('User:', data.user);
 
-// Check authentication
 if (spaps.isAuthenticated()) {
-  const user = await spaps.getUser();
-  console.log('Current user:', user.data);
+  const me = await spaps.getUser();
+  console.log(me.data.email);
 }
 ```
 
-## Local Mode Explained
-
-- If `apiUrl` is omitted or points to `localhost`/`127.0.0.1`, the SDK runs in local mode.
-- Local mode integrates seamlessly with the `spaps` CLI (`npx spaps local`), defaulting to `http://localhost:3301`.
-- No API key is required in local mode; tokens and data are managed locally for development.
-
-You can check the mode at runtime:
-
-```ts
-spaps.isLocalMode(); // true | false
-```
-
-## Environment Variables
-
-The SDK can read configuration from environment variables (useful in Next.js and Node):
-
-- `SPAPS_API_URL` or `NEXT_PUBLIC_SPAPS_API_URL` — API base URL
-- `SPAPS_API_KEY` — API key for production use
-
-Example (Node):
-
-```bash
-export SPAPS_API_URL=https://api.sweetpotato.dev
-export SPAPS_API_KEY=spaps_xxx
-```
-
-Example (Next.js):
-
-```env
-NEXT_PUBLIC_SPAPS_API_URL=https://api.sweetpotato.dev
-```
-
-## Features
+## Configuration
 
-### 🚀 Zero Configuration
-- **Auto-detects local mode** - No API key needed for localhost
-- **Auto-refreshes tokens** - Handles expired tokens automatically
-- **TypeScript support** - Full type definitions included
-- **Crypto payments ready** - Create invoices, poll status, verify webhooks, trigger reconciliation
+Constructor values win over environment variables.
 
-### 🔐 Authentication Methods
-```javascript
-// Email/Password
-await spaps.login(email, password);
-await spaps.register(email, password);
+| Option | Purpose |
+| --- | --- |
+| `apiUrl` | Base API URL. Localhost enables local mode automatically. |
+| `publishableKey` | Browser-safe key for client-side usage |
+| `secretKey` | Server-side key for full access |
+| `apiKey` | Deprecated legacy key field |
+| `timeout` | Override request timeout |
 
-// Wallet Authentication
-await spaps.walletSignIn(walletAddress, signature, message, 'solana');
+Relevant environment variables:
 
-// Token Management
-await spaps.refresh();
-await spaps.logout();
+- `SPAPS_API_URL`
+- `NEXT_PUBLIC_SPAPS_API_URL`
+- `SPAPS_API_KEY`
+- `NEXT_PUBLIC_SPAPS_API_KEY`
 
-// Get User
-const user = await spaps.getUser();
-```
+## Client Surface
 
-### 💳 Stripe Integration
-```javascript
-// Create checkout session with consent control
-const session = await spaps.payments.createPaymentCheckout({
-  price_id: 'price_123',
-  success_url: 'https://app.example.com/success',
-  cancel_url: 'https://app.example.com/cancel',
-  require_legal_consent: true,
-  legal_consent_text: 'I agree I am 18+ and accept the HTMA Terms & Privacy.'
-});
-window.location.href = session.url;
+| Namespace | What It Covers |
+| --- | --- |
+| `auth` | Password, wallet, magic-link, refresh, and logout flows |
+| `payments` | Checkout sessions, products, prices, subscriptions, and crypto payment helpers |
+| `sessions` | Current session lookup, validation, revocation, and session lifecycle helpers |
+| `secureMessages` | Create and list secure messages |
+| `issueReporting` | Status, history, create, edit, and reply issue-report flows |
+| `email` | Template lookup, previews, and sends |
+| `entitlements` | User and resource entitlement queries |
+| `dayrate` | Availability and booking helpers |
+| `admin` | Product and pricing admin helpers |
+| `cfo` | CFO-specific endpoints |
 
-// Manage subscription
-const subscription = await spaps.getSubscription();
-await spaps.cancelSubscription();
-```
-> `require_legal_consent` forces Stripe’s Terms/Privacy checkbox, and `legal_consent_text` (≤120 chars) customizes the copy. Text is sanitized and defaults to “I agree to the Terms of Service and Privacy Policy.” when omitted.
+## Common Flows
 
-### 📊 Usage Tracking
-```javascript
-// Check balance
-const balance = await spaps.getUsageBalance();
-console.log(`Credits: ${balance.data.balance}`);
-
-// Record usage
-await spaps.recordUsage('api-call', 1);
-```
-
-### ✉️ Secure Messaging
-```javascript
-// Create a secure message (content encrypted server-side when pii_enabled)
-const message = await spaps.secureMessages.create({
-  patientId: '3d6f0a51-8d77-4b38-8248-2d1b2f1f6c7f',
-  practitionerId: 'a3d7f431-6c9d-4cbc-9f78-4e5b6a7c8d9e',
-  content: 'Patient is experiencing intermittent headaches.',
-  metadata: { urgency: 'high' }
-});
-
-// List secure messages for the current application
-const messages = await spaps.secureMessages.list();
-console.log(messages[0].content);
-```
-> Ensure your application has `settings.pii_enabled = true` so payloads are encrypted automatically.
+### Typed Secure Messaging
 
 ```typescript
-// Provide a strongly typed metadata shape for downstream usage
 type SecureMessageMetadata = { urgency: 'low' | 'high'; tags?: string[] };
 
-const spaps = new SPAPSClient<SecureMessageMetadata>({ apiKey: process.env.SPAPS_API_KEY });
+const spaps = new SPAPSClient<SecureMessageMetadata>({
+  apiUrl: 'https://api.sweetpotato.dev',
+  secretKey: process.env.SPAPS_API_KEY,
+});
 
 await spaps.secureMessages.create({
   patientId: '3d6f0a51-8d77-4b38-8248-2d1b2f1f6c7f',
   practitionerId: 'a3d7f431-6c9d-4cbc-9f78-4e5b6a7c8d9e',
   content: 'Follow up scheduled for next week.',
-  metadata: { urgency: 'low', tags: ['follow-up'] }
+  metadata: { urgency: 'low', tags: ['follow-up'] },
 });
-
-const typedMessages = await spaps.secureMessages.list();
-typedMessages[0].metadata.urgency; // "low" | "high"
 ```
 
-Need runtime validation too? Reuse the shared schemas that ship with the SDK:
+### Shared Issue Reporting
 
 ```typescript
-import { z } from 'zod';
-import { createSecureMessageRequestSchema } from 'spaps-sdk';
-
-const secureMessageRequestSchema = createSecureMessageRequestSchema(
-  z.object({ urgency: z.enum(['low', 'high']), tags: z.array(z.string()).optional() })
-);
-
-secureMessageRequestSchema.parse({
-  patientId: '3d6f0a51-8d77-4b38-8248-2d1b2f1f6c7f',
-  practitionerId: 'a3d7f431-6c9d-4cbc-9f78-4e5b6a7c8d9e',
-  content: 'All clear.',
-  metadata: { urgency: 'low' }
-});
+spaps.setAccessToken('jwt-token');
+
+const summary = await spaps.issueReporting.getStatus();
+const history = await spaps.issueReporting.list({ status: 'open' });
+
+if (!summary.has_open && history.total === 0) {
+  await spaps.issueReporting.create({
+    target: {
+      component_key: 'patient_protocol_widget',
+      component_label: 'Patient Protocol Widget',
+      page_url: '/patients/123/protocol',
+      metadata: { section: 'daily log' },
+    },
+    note: 'The save action silently fails after I edit today.',
+    reporter_role_hint: 'practitioner',
+  });
+}
 ```
 
-## Configuration
-
-### Production Mode
-```javascript
-const spaps = new SPAPSClient({
-  apiUrl: 'https://api.sweetpotato.dev',
-  apiKey: 'spaps_your_api_key_here',
-  timeout: 10000 // Optional timeout in ms
-});
-```
+### Permission Utilities
 
-### Local Development Mode (Auto-detected)
-```javascript
-const spaps = new SPAPSClient();
-// Automatically uses http://localhost:3301 with no API key
-```
+```typescript
+import { canAccessAdmin, getUserRole, isAdminAccount } from 'spaps-sdk';
 
-### Environment Variables
-```bash
-# .env
-SPAPS_API_URL=https://api.sweetpotato.dev
-SPAPS_API_KEY=spaps_your_api_key_here
+const role = getUserRole('user@example.com');
+const adminCheck = canAccessAdmin({ id: 'user_123', email: 'buildooor@gmail.com' });
+const isAdmin = isAdminAccount('buildooor@gmail.com');
 
-# Next.js
-NEXT_PUBLIC_SPAPS_API_URL=https://api.sweetpotato.dev
+console.log(role, adminCheck.allowed, isAdmin);
 ```
 
-## Helper Methods
+### Helper Methods
 
-```javascript
-// Check if authenticated
-spaps.isAuthenticated() // boolean
-
-// Get current access token
-spaps.getAccessToken() // string | undefined
+```typescript
+const spaps = new SPAPSClient({ apiUrl: 'http://localhost:3301' });
 
-// Set access token manually
-spaps.setAccessToken(token)
+spaps.isLocalMode();
+spaps.isAuthenticated();
+spaps.getAccessToken();
+spaps.setAccessToken('token');
+await spaps.health();
+```
 
-// Check if in local mode
-spaps.isLocalMode() // boolean
+## Development
 
-// Health check
-await spaps.health()
+```bash
+cd packages/sdk
+npm ci
+npm run build
+npm run typecheck:readme
+npm run test:readme
+npm run test
 ```
 
-## Types
+## Troubleshooting
 
-The SDK ships with full TypeScript definitions. For most apps, import types directly from `spaps-sdk`:
+### `401 Unauthorized`
 
-```ts
-import { SPAPSClient, type User, type Session, type Role } from 'spaps-sdk';
-```
+Check the access token and key configuration for the environment you are targeting.
 
-For advanced or library use cases, you can also import canonical types from the standalone package:
+### Local mode is not activating
 
-```ts
-import type {
-  User,
-  Session,
-  Role,
-  Permission,
-  TokenPayload,
-} from 'spaps-types';
-```
+Use a localhost URL such as `http://localhost:3301`, or call `spaps.isLocalMode()` to confirm how the SDK resolved the environment.
 
-Notes:
-- `spaps-sdk` re-exports commonly used types for convenience.
-- `spaps-types` is useful when building framework integrations, server middleware, or utilities that need to share types without depending on the SDK runtime.
+### Browser app needs limited access
 
-## Import Styles
+Use `publishableKey` instead of a server-side secret key.
 
-All these work:
-```javascript
-// ES6 Import
-import { SPAPSClient } from 'spaps-sdk';
-import SPAPSClient from 'spaps-sdk';
+## Limitations
 
-// CommonJS
-const { SPAPSClient } = require('spaps-sdk');
-const SPAPSClient = require('spaps-sdk');
+- The SDK wraps the current SPAPS surface; it is not an exhaustive code-generated client for every backend route.
+- Some admin and entitlement flows still depend on upstream permissions and token context.
+- The legacy `apiKey` constructor field still exists for compatibility, but new integrations should prefer the explicit key fields.
 
-// Alternative names
-import { SPAPS } from 'spaps-sdk';
-import { SweetPotatoSDK } from 'spaps-sdk';
-```
+## FAQ
 
-## Admin API Methods
+### Does this work in browsers?
 
-The SDK includes comprehensive admin methods for Stripe product management:
+Yes. The package is designed for both browser and server-side usage.
 
-### Product Management
+### Does it include fetch polyfills?
 
-```typescript
-// Create product (Admin required)
-const product = await spaps.admin.createProduct({
-  name: 'Premium Plan',
-  category: 'subscription',
-  description: 'Advanced features for power users',
-  images: ['https://example.com/product-image.jpg'],
-  metadata: { feature_set: 'premium' },
-  active: true
-});
+Yes. It loads `cross-fetch/polyfill` when `fetch` is unavailable.
 
-// Update product (Admin required)
-const updatedProduct = await spaps.admin.updateProduct('prod_123', {
-  name: 'Premium Plan Pro',
-  description: 'Updated features'
-});
+### Can I use it without TypeScript?
 
-// Archive product (Admin required)
-await spaps.admin.deleteProduct('prod_123');
+Yes. The runtime works in JavaScript projects and ships bundled type declarations for TS users.
 
-// Get products (includes admin metadata if user is admin)
-const { data } = await spaps.admin.getProducts();
-if (data.adminMetadata) {
-  console.log('Total revenue:', data.adminMetadata.total_revenue);
-}
-```
+### Does it re-export shared types?
 
-### Price Management
+Yes. Many `spaps-types` exports are re-exported for convenience.
 
-```typescript
-// Create price (Admin required)
-const price = await spaps.admin.createPrice({
-  product_id: 'prod_123',
-  unit_amount: 2999, // $29.99
-  currency: 'usd',
-  interval: 'month',
-  interval_count: 1,
-  nickname: 'Monthly Premium'
-});
-```
+### How do I validate README-related examples?
 
-### Super Admin Operations
+Run:
 
-```typescript
-// Sync all products from Stripe (Super Admin required)
-const syncResult = await spaps.admin.syncProducts();
-console.log(`Synced ${syncResult.data.synced_count} products`);
+```bash
+npm run typecheck:readme
+npm run test:readme
 ```
 
-### Permission Checking
+## About Contributions
 
-```typescript
-// Check if current user can access admin features
-const user = await spaps.getCurrentUser();
-if (spaps.isAdmin(user)) {
-  // Show admin UI components
-  console.log('User has admin privileges');
-} else {
-  // Show regular user UI
-  console.log('Regular user');
-}
-```
-
-## Error Handling
-
-```javascript
-try {
-  await spaps.admin.createProduct(productData);
-} catch (error) {
-  if (error.response?.status === 401) {
-    console.error('Authentication required');
-  } else if (error.response?.status === 403) {
-    console.error('Admin privileges required');
-  } else if (error.response?.status === 429) {
-    console.error('Rate limited');
-  } else {
-    console.error('Error:', error.message);
-  }
-}
-```
+*About Contributions:* Please don't take this the wrong way, but I do not accept outside contributions for any of my projects. I simply don't have the mental bandwidth to review anything, and it's my name on the thing, so I'm responsible for any problems it causes; thus, the risk-reward is highly asymmetric from my perspective. I'd also have to worry about other "stakeholders," which seems unwise for tools I mostly make for myself for free. Feel free to submit issues, and even PRs if you want to illustrate a proposed fix, but know I won't merge them directly. Instead, I'll have Claude or Codex review submissions via `gh` and independently decide whether and how to address them. Bug reports in particular are welcome. Sorry if this offends, but I want to avoid wasted time and hurt feelings. I understand this isn't in sync with the prevailing open-source ethos that seeks community contributions, but it's the only way I can move at this velocity and keep my sanity.
 
 ## License
 

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import * as spaps_types from 'spaps-types';
-import { ResourceType, Entitlement, CreateProductRequest, Product, UpdateProductRequest, CreatePriceRequest, Price, ProductSyncResult, CryptoReconcileRequest, CreateSecureMessageRequest, SecureMessage, AuthResponse, User as User$1, CreateCryptoInvoiceRequest, CryptoInvoiceStatusSnapshot, CheckoutSession, DayrateAvailabilityResponse, DayrateBookingRequest, DayrateBookingResponse, DayrateMultiBookingRequest, DayrateMultiBookingResponse, Subscription, UsageBalance, VerifyCryptoWebhookSignatureOptions } from 'spaps-types';
-export { AdminPermission, AdminRole, AdminUser, ApiResponse, AuthResponse, CheckoutSession, CreateCryptoInvoiceRequest, CreatePriceRequest, CreateProductRequest, CreateSecureMessageInput, CreateSecureMessageRequest, CryptoInvoice, CryptoInvoiceResponse, CryptoInvoiceStatusSnapshot, CryptoReconcileRequest, DayrateAvailabilityResponse, DayrateAvailableSlot, DayrateBookingRequest, DayrateBookingResponse, DayrateDayOfWeek, DayrateMultiBookingRequest, DayrateMultiBookingResponse, DayratePriceBreakdown, DayrateSlotType, Entitlement, Price, Product, ProductSyncResult, ResourceType, SecureMessage, SecureMessageOutput, Subscription, TokenPair, UpdateProductRequest, UsageBalance, User, UserProfile, UserRole, UserWallet, VerifyCryptoWebhookSignatureOptions, createSecureMessageRequestSchema, secureMessageMetadataSchema, secureMessageSchema } from 'spaps-types';
+import { ResourceType, Entitlement, CreateProductRequest, Product, UpdateProductRequest, CreatePriceRequest, Price, ProductSyncResult, CryptoReconcileRequest, CreateSecureMessageRequest, SecureMessage, IssueReportStatusResult, IssueReportStatus, IssueReportListResult, IssueReport, CreateIssueReportRequest, UpdateIssueReportRequest, ReplyIssueReportRequest, AuthResponse, User as User$1, CreateCryptoInvoiceRequest, CryptoInvoiceStatusSnapshot, CheckoutSession, DayrateAvailabilityResponse, DayrateBookingRequest, DayrateBookingResponse, DayrateMultiBookingRequest, DayrateMultiBookingResponse, Subscription, UsageBalance, VerifyCryptoWebhookSignatureOptions } from 'spaps-types';
+export { AdminPermission, AdminRole, AdminUser, ApiResponse, AuthResponse, CheckoutSession, CreateCryptoInvoiceRequest, CreateIssueReportRequest, CreatePriceRequest, CreateProductRequest, CreateSecureMessageInput, CreateSecureMessageRequest, CryptoInvoice, CryptoInvoiceResponse, CryptoInvoiceStatusSnapshot, CryptoReconcileRequest, DayrateAvailabilityResponse, DayrateAvailableSlot, DayrateBookingRequest, DayrateBookingResponse, DayrateDayOfWeek, DayrateMultiBookingRequest, DayrateMultiBookingResponse, DayratePriceBreakdown, DayrateSlotType, Entitlement, IssueReport, IssueReportListResult, IssueReportStatus, IssueReportStatusResult, IssueReportTarget, LinkedIssueReportCase, Price, Product, ProductSyncResult, ReplyIssueReportRequest, ResourceType, SecureMessage, SecureMessageOutput, Subscription, TokenPair, UpdateIssueReportRequest, UpdateProductRequest, UsageBalance, User, UserProfile, UserRole, UserWallet, VerifyCryptoWebhookSignatureOptions, createSecureMessageRequestSchema, secureMessageMetadataSchema, secureMessageSchema } from 'spaps-types';
 
 /**
  * Permission checking utilities for SPAPS SDK
@@ -344,6 +344,11 @@ interface EntitlementCheckResult {
     /** The matching entitlement, if any */
     entitlement?: Entitlement;
 }
+interface IssueReportListParams {
+    status?: IssueReportStatus;
+    limit?: number;
+    offset?: number;
+}
 
 declare class SPAPSClient<SecureMessageMetadata extends Record<string, any> = Record<string, any>> {
     private client;
@@ -429,6 +434,35 @@ declare class SPAPSClient<SecureMessageMetadata extends Record<string, any> = Re
          */
         listByResource: (resourceType: ResourceType, resourceId?: string) => Promise<Entitlement[]>;
     };
+    /**
+     * Issue reporting namespace for authenticated end-user issue flows.
+     */
+    issueReporting: {
+        /**
+         * Return canonical issue-report summary for the shared floating entrypoint.
+         */
+        getStatus: () => Promise<IssueReportStatusResult>;
+        /**
+         * List the caller's issue reports inside the active application scope.
+         */
+        list: (params?: IssueReportListParams) => Promise<IssueReportListResult>;
+        /**
+         * Hydrate one canonical issue report by ID.
+         */
+        get: (issueReportId: string) => Promise<IssueReport>;
+        /**
+         * Create a new canonical issue report.
+         */
+        create: (payload: CreateIssueReportRequest) => Promise<IssueReport>;
+        /**
+         * Update the note for an unresolved issue report.
+         */
+        update: (issueReportId: string, payload: UpdateIssueReportRequest) => Promise<IssueReport>;
+        /**
+         * Reply to a resolved or ignored issue report and reopen the linked case.
+         */
+        reply: (issueReportId: string, payload: ReplyIssueReportRequest) => Promise<IssueReport>;
+    };
     constructor(config?: SPAPSConfig);
     /** Raw API request helper that returns an ApiResponse-like shape */
     request<T = any>(method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH', url: string, data?: any, requiresAuth?: boolean): Promise<{
@@ -895,4 +929,4 @@ declare function createServerClient(secretKey: string, options?: Omit<SPAPSConfi
  */
 declare function detectKeyType(key: string): ApiKeyType | null;
 
-export { type AdminConfig, type ApiKeyType, type CheckoutLineItem, type CheckoutLineItemPriceData, type CreateCheckoutSessionPayload, DEFAULT_ADMIN_ACCOUNTS, type EmailSendOptions, type EmailSendResult, type EmailTemplate, type EmailTemplatePreview, type EntitlementCheckResult, type EntitlementListParams, type FeatureContext, type FeatureDefinition, FeatureEvaluator, type PermissionCheckResult, PermissionChecker, RoleHierarchy, SPAPSClient as SPAPS, SPAPSClient, type SPAPSConfig, type TemplateVariable, TokenManager, WalletUtils, WebSocketAuthHelper, type WebSocketAuthHelperConfig, canAccessAdmin, createBrowserClient, createPermissionChecker, createServerClient, SPAPSClient as default, defaultPermissionChecker, detectKeyType, getRoleAwareErrorMessage, getUserDisplay, getUserRole, hasPermission, isAdminAccount, verifyCryptoWebhookSignature };
+export { type AdminConfig, type ApiKeyType, type CheckoutLineItem, type CheckoutLineItemPriceData, type CreateCheckoutSessionPayload, DEFAULT_ADMIN_ACCOUNTS, type EmailSendOptions, type EmailSendResult, type EmailTemplate, type EmailTemplatePreview, type EntitlementCheckResult, type EntitlementListParams, type FeatureContext, type FeatureDefinition, FeatureEvaluator, type IssueReportListParams, type PermissionCheckResult, PermissionChecker, RoleHierarchy, SPAPSClient as SPAPS, SPAPSClient, type SPAPSConfig, type TemplateVariable, TokenManager, WalletUtils, WebSocketAuthHelper, type WebSocketAuthHelperConfig, canAccessAdmin, createBrowserClient, createPermissionChecker, createServerClient, SPAPSClient as default, defaultPermissionChecker, detectKeyType, getRoleAwareErrorMessage, getUserDisplay, getUserRole, hasPermission, isAdminAccount, verifyCryptoWebhookSignature };