@jmruthers/pace-core 0.6.9 → 0.6.11

package/cursor-rules/08-testing-documentation.mdc

@@ -21,6 +21,7 @@ This guide ensures consistent, high-quality testing and documentation across con
 5. **Colocate tests** - Place test files next to source files (`Component.test.tsx` next to `Component.tsx`)
 6. **Use descriptive names** - Test names should clearly describe the behavior being tested
 7. **Group related tests** - Use `describe` blocks to organize related tests
+8. **When fixing testing or documentation issues** - Use the **audit report** (`audit/<timestamp>-pace-core-audit.md`) and the **standard doc** section linked from the report; fix the cause (e.g. test timeouts, testing tools, test file naming), do not silence tools. Re-run **`npm run validate`** to confirm.
 
 **Decision Tree: Writing Tests**
 ```

package/cursor-rules/09-operations.mdc

@@ -21,6 +21,7 @@ This guide enforces error handling patterns, performance optimization strategies
 5. **Avoid new objects in render** - Never create new objects/arrays in render, memoize them with `useMemo`
 6. **Use helper functions in RLS** - Always use STABLE SECURITY DEFINER helper functions, never subqueries
 7. **Provide recovery paths** - When possible, provide retry logic or fallback values
+8. **When fixing operations or error-handling issues** - Use the **audit report** (`audit/<timestamp>-pace-core-audit.md`) and the **standard doc** section linked from the report; fix the cause (e.g. ApiResult usage, CI/CD setup, ErrorBoundary), do not silence tools. Re-run **`npm run validate`** to confirm.
 
 **Decision Tree: Error Handling**
 ```

package/dist/DataTable-EFYP2QLE.js

@@ -0,0 +1,16 @@
+export { ActionButtons, BulkOperationsDropdown, ColumnFactory, ColumnVisibilityDropdown, DataTable, DataTableCore, DataTableErrorBoundary, DataTableModals, DataTableToolbar, EditableRow, EmptyState, EnhancedPaginationControls, GroupingDropdown, ImportModal, LoadingState, PaginationControls, SortIndicator, UnifiedTableBody, announce, announceBulkOperation, announceFilterChange, announceLoadingState, announcePaginationChange, announceSearchResults, announceSelectionChange, announceSortChange, average, calculateAllDepths, calculateAllIndentation, calculateIndentation, calculateOptimalPageSize, cleanupLiveRegion, count, createHierarchicalStructure, defaultDataTableFeatures, exportToCSV, exportToCSVWithTableRows, findSelectLabel, generateCSVContent, getAriaSortState, getAriaSortValue, getCellRenderer, getColumnHeaderText, getHierarchicalSortConfig, getPageSizeOptions, getPaginationBinding, getRowDepth, getRowDescription, getRowIdSafe, getSortButtonLabel, groupHierarchicalData, hasValidRowId, initializeLiveRegion, isHierarchicalSortableColumn, max, min, normalizeDataTableFeatures, optionMatchesSearch, shouldShowColumnForRow, sortHierarchicalDataByStructure, sortHierarchicalDataWithSorting, sum, validateHierarchicalData, validatePaginationConfig } from './chunk-2OEVOGGR.js';
+import './chunk-V7FTM2LU.js';
+export { CircuitBreaker, DEFAULT_FALLBACK_CONFIG, DataChunkManager, DataTableError, DataTableErrorType, ErrorRecoveryManager, MemoryMonitor, SearchIndex, VisibilityTracker, chunkData, debounce, determinePaginationMode, getOptimalPageSizeOptions, safeExecute, throttle, useDataTablePerformance } from './chunk-ENLXB7GP.js';
+import './chunk-L5LFKKLJ.js';
+import './chunk-4R3T5ENU.js';
+import './chunk-D6BMFMQZ.js';
+import './chunk-7A6IMHH2.js';
+import './chunk-QRYSEPHB.js';
+import './chunk-4SXLQIZO.js';
+import './chunk-DDMPHZ3D.js';
+import './chunk-UZNAFKGW.js';
+import './chunk-RMLY6KB5.js';
+import './chunk-BTHN5MKC.js';
+import './chunk-44CNXN4P.js';
+import './chunk-CU2BU2MQ.js';
+import './chunk-3RG5ZIWI.js';

package/dist/InactivityServiceProvider-BbxwwDz1.d.ts

@@ -0,0 +1,308 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React__default from 'react';
+import { SupabaseClient, User, Session } from '@supabase/supabase-js';
+import { O as Organisation, j as OrganisationMembership, s as OrganisationHierarchy } from './event-BfCox3N2.js';
+
+/**
+ * Props for the EventServiceProvider component.
+ */
+interface EventServiceProviderProps {
+    children: React__default.ReactNode;
+    supabaseClient: SupabaseClient;
+    user: User | null;
+    session: Session | null;
+    appName: string;
+    selectedOrganisation: Organisation | null;
+    setSelectedEventId: (eventId: string | null) => void;
+}
+/**
+ * React provider for EventService.
+ * Provides event service instance to React components.
+ *
+ * @param props - Event service provider configuration
+ * @returns The event service provider
+ */
+declare function EventServiceProvider({ children, supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId }: EventServiceProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * @file Base Service Class
+ * @package @jmruthers/pace-core
+ * @module Services/Base
+ * @since 0.1.0
+ *
+ * Base service class implementing the observable pattern for React subscriptions.
+ * All services extend this class to provide state change notifications.
+ */
+type StateChangeCallback = () => void;
+declare abstract class BaseService {
+    private subscribers;
+    private isInitialized;
+    /**
+     * Subscribe to state changes
+     * @param callback Function to call when state changes
+     * @returns Unsubscribe function
+     */
+    subscribe(callback: StateChangeCallback): () => void;
+    /**
+     * Notify all subscribers of state changes
+     * This triggers React re-renders
+     */
+    protected notify(): void;
+    /**
+     * Initialize the service
+     * Override in subclasses to implement initialization logic
+     */
+    initialize(): Promise<void>;
+    /**
+     * Cleanup the service
+     * Override in subclasses to implement cleanup logic
+     */
+    cleanup(): void;
+    /**
+     * Check if service is initialized
+     */
+    protected getInitialized(): boolean;
+    /**
+     * Reset initialization state (allows re-initialization)
+     * Use when dependencies change and service needs to re-initialize
+     */
+    protected resetInitialization(): void;
+    /**
+     * Override in subclasses to implement initialization logic
+     */
+    protected abstract doInitialize(): Promise<void>;
+    /**
+     * Override in subclasses to implement cleanup logic
+     */
+    protected abstract doCleanup(): void;
+}
+
+/**
+ * @file Organisation Service Interface
+ * @package @jmruthers/pace-core
+ * @module Services/Interfaces
+ * @since 0.1.0
+ *
+ * Interface for organisation service operations.
+ * Defines the contract for organisation management functionality.
+ */
+
+interface IOrganisationService {
+    getSelectedOrganisation(): Organisation | null;
+    getOrganisations(): Organisation[];
+    getUserMemberships(): OrganisationMembership[];
+    isLoading(): boolean;
+    getError(): Error | null;
+    hasValidOrganisationContext(): boolean;
+    isContextReady(): boolean;
+    switchOrganisation(orgId: string): Promise<void>;
+    getUserRole(orgId?: string): string;
+    validateOrganisationAccess(orgId: string): boolean;
+    refreshOrganisations(): Promise<void>;
+    ensureOrganisationContext(): Organisation;
+    isOrganisationSecure(): boolean;
+    getPrimaryOrganisation(): Organisation | null;
+    buildOrganisationHierarchy(orgs: Organisation[]): OrganisationHierarchy[];
+    initialize(): Promise<void>;
+    cleanup(): void;
+}
+
+/**
+ * @file Organisation Service
+ * @package @jmruthers/pace-core
+ * @module Services
+ * @since 0.1.0
+ *
+ * Organisation service implementation.
+ * Handles organisation management and selection with security-first approach.
+ */
+
+declare class OrganisationService extends BaseService implements IOrganisationService {
+    private static instanceCount;
+    private instanceId;
+    private _selectedOrganisation;
+    private _organisations;
+    private _userMemberships;
+    private _roleMapState;
+    private _isLoading;
+    private _error;
+    private _isSuperAdmin;
+    private _isContextReady;
+    private retryCount;
+    private supabaseClient;
+    private user;
+    private session;
+    private isLoadingRef;
+    private lastLoadTimeRef;
+    private hasFailedRef;
+    private abortControllerRef;
+    constructor(supabaseClient: SupabaseClient, user: User | null, session: Session | null);
+    getInstanceId(): number;
+    getSelectedOrganisation(): Organisation | null;
+    getOrganisations(): Organisation[];
+    getUserMemberships(): OrganisationMembership[];
+    isLoading(): boolean;
+    getError(): Error | null;
+    hasValidOrganisationContext(): boolean;
+    isContextReady(): boolean;
+    setSelectedOrganisation(organisation: Organisation | null): void;
+    getDependencies(): {
+        user: User | null;
+        session: Session | null;
+        supabaseClient: SupabaseClient | null;
+    };
+    setTestState(organisations: Organisation[], memberships: OrganisationMembership[], roleMap: Map<string, string>, selectedOrg?: Organisation | null): void;
+    updateDependencies(user: User | null, session: Session | null): void;
+    switchOrganisation(orgId: string): Promise<void>;
+    getUserRole(orgId?: string): string;
+    validateOrganisationAccess(orgId: string): boolean;
+    refreshOrganisations(): Promise<void>;
+    ensureOrganisationContext(): Organisation;
+    isOrganisationSecure(): boolean;
+    getPrimaryOrganisation(): Organisation | null;
+    buildOrganisationHierarchy(orgs: Organisation[]): OrganisationHierarchy[];
+    initialize(): Promise<void>;
+    cleanup(): void;
+    protected doInitialize(): Promise<void>;
+    protected doCleanup(): void;
+    private setDatabaseOrganisationContext;
+    /** Returns false if load should return early; when true, abort controller and loading state are set. */
+    private prepareLoad;
+    private fetchRolesAndOrganisations;
+    private checkAndCacheSuperAdmin;
+    private applyEmptyStateAndNotify;
+    private selectInitialOrganisation;
+    private loadUserOrganisations;
+    private clearAllCachedData;
+}
+
+/**
+ * Props for the OrganisationServiceProvider component.
+ */
+interface OrganisationServiceProviderProps {
+    children: React__default.ReactNode;
+    supabaseClient: SupabaseClient;
+    user: User | null;
+    session: Session | null;
+}
+/**
+ * React provider for OrganisationService.
+ * Provides organisation service instance to React components.
+ *
+ * @param props - Organisation service provider configuration
+ * @returns The organisation service provider
+ */
+declare function OrganisationServiceProvider({ children, supabaseClient, user, session }: OrganisationServiceProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * @file Inactivity Service Interface
+ * @package @jmruthers/pace-core
+ * @module Services/Interfaces
+ * @since 0.1.0
+ *
+ * Interface for inactivity service operations.
+ * Defines the contract for inactivity tracking functionality.
+ */
+interface IInactivityService {
+    isIdle(): boolean;
+    getTimeRemaining(): number;
+    isWarningShown(): boolean;
+    isTracking(): boolean;
+    getShowInactivityWarning(): boolean;
+    getInactivityTimeRemaining(): number;
+    resetActivity(): void;
+    startTracking(): void;
+    stopTracking(): void;
+    handleIdleLogout(): Promise<void>;
+    handleStaySignedIn(): void;
+    handleSignOutNow(): Promise<void>;
+    initialize(): Promise<void>;
+    cleanup(): void;
+}
+
+/**
+ * @file Inactivity Service
+ * @package @jmruthers/pace-core
+ * @module Services
+ * @since 0.1.0
+ *
+ * Inactivity service implementation.
+ * Handles inactivity tracking, auto-logout, and warning modals.
+ */
+
+declare class InactivityService extends BaseService implements IInactivityService {
+    private _showInactivityWarning;
+    private _inactivityTimeRemaining;
+    private _isIdle;
+    private _timeRemaining;
+    private _showWarning;
+    private _isTracking;
+    private supabaseClient;
+    private user;
+    private session;
+    private idleTimeoutMs;
+    private warnBeforeMs;
+    private onIdleLogout;
+    private inactivityTracker;
+    private isInactivityEnabled;
+    private cleanupHandlers;
+    constructor(supabaseClient: SupabaseClient | null, user: User | null, session: Session | null, idleTimeoutMs: number | undefined, warnBeforeMs: number | undefined, onIdleLogout: (reason: 'inactivity') => void);
+    isIdle(): boolean;
+    getTimeRemaining(): number;
+    isWarningShown(): boolean;
+    isTracking(): boolean;
+    getShowInactivityWarning(): boolean;
+    getInactivityTimeRemaining(): number;
+    getIsIdle(): boolean;
+    getIsTracking(): boolean;
+    getShowWarning(): boolean;
+    setShowInactivityWarning(value: boolean): void;
+    setInactivityTimeRemaining(value: number): void;
+    setIsIdle(value: boolean): void;
+    setTimeRemaining(value: number): void;
+    setShowWarning(value: boolean): void;
+    setIsTracking(value: boolean): void;
+    triggerWarning(timeRemaining: number): void;
+    triggerIdle(): void;
+    updateDependencies(supabaseClient: SupabaseClient | null, user: User | null, session: Session | null, idleTimeoutMs?: number, warnBeforeMs?: number, onIdleLogout?: (reason: 'inactivity') => void): void;
+    resetActivity(): void;
+    startTracking(): void;
+    stopTracking(): void;
+    handleIdleLogout(): Promise<void>;
+    handleStaySignedIn(): void;
+    handleSignOutNow(): Promise<void>;
+    initialize(): Promise<void>;
+    cleanup(): void;
+    protected doInitialize(): Promise<void>;
+    protected doCleanup(): void;
+    private setupInactivityTracker;
+    private runUpdateState;
+    private runScheduleNextCheck;
+    private runResetTimers;
+    private setupEventHandlers;
+}
+
+/**
+ * Props for the InactivityServiceProvider component.
+ */
+interface InactivityServiceProviderProps {
+    children: React__default.ReactNode;
+    supabaseClient: SupabaseClient;
+    user: User | null;
+    session: Session | null;
+    idleTimeoutMs: number;
+    warnBeforeMs: number;
+    onIdleLogout: (reason: 'inactivity') => void;
+}
+/**
+ * React provider for InactivityService.
+ * Provides inactivity service instance to React components.
+ *
+ * @param props - Inactivity service provider configuration
+ * @returns The inactivity service provider
+ */
+declare function InactivityServiceProvider({ children, supabaseClient, user, session, idleTimeoutMs, // REQUIRED: No default - must be explicitly provided
+warnBeforeMs, // REQUIRED: No default - must be explicitly provided
+onIdleLogout }: InactivityServiceProviderProps): react_jsx_runtime.JSX.Element;
+
+export { BaseService as B, type EventServiceProviderProps as E, InactivityService as I, OrganisationService as O, EventServiceProvider as a, type OrganisationServiceProviderProps as b, OrganisationServiceProvider as c, type InactivityServiceProviderProps as d, InactivityServiceProvider as e };

package/dist/UnifiedAuthProvider-Bkt_tzdS.d.ts

@@ -0,0 +1,183 @@
+import * as React from 'react';
+import React__default from 'react';
+import { User, Session, AuthError, SupabaseClient } from '@supabase/supabase-js';
+import { A as ApiResult } from './api-result-USV1Czr-.js';
+import { O as Organisation, j as OrganisationMembership, h as Event } from './event-BfCox3N2.js';
+import { a as SessionRestorationState } from './auth-JvdRVaud.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/**
+ * @file Authentication Service Interface
+ * @package @jmruthers/pace-core
+ * @module Services/Interfaces
+ * @since 0.1.0
+ *
+ * Interface for authentication service operations.
+ * Defines the contract for authentication-related functionality.
+ */
+
+/** Success payload for auth methods: user and session (both null when signed out). */
+interface AuthSessionData {
+    user: User | null;
+    session: Session | null;
+}
+interface IAuthService {
+    getUser(): User | null;
+    getSession(): Session | null;
+    isAuthenticated(): boolean;
+    isLoading(): boolean;
+    getError(): AuthError | null;
+    getSupabaseClient(): SupabaseClient | null;
+    signIn(email: string, password?: string): Promise<ApiResult<AuthSessionData>>;
+    signUp(email: string, password: string): Promise<ApiResult<AuthSessionData>>;
+    signOut(): Promise<ApiResult<AuthSessionData>>;
+    resetPassword(email: string): Promise<ApiResult<AuthSessionData>>;
+    updatePassword(password: string): Promise<ApiResult<AuthSessionData>>;
+    refreshSession(): Promise<ApiResult<AuthSessionData>>;
+    initialize(): Promise<void>;
+    cleanup(): void;
+}
+
+/** Auth state and methods for unified auth context (ISP). */
+interface UnifiedAuthContextAuth {
+    user: User | null;
+    session: Session | null;
+    isAuthenticated: boolean;
+    authLoading: boolean;
+    authError: AuthError | null;
+    supabase: SupabaseClient | null;
+    appName: string;
+    appId: string | undefined;
+    signIn: (email: string, password?: string) => Promise<ApiResult<AuthSessionData>>;
+    signUp: (email: string, password: string) => Promise<ApiResult<AuthSessionData>>;
+    signOut: () => Promise<ApiResult<AuthSessionData>>;
+    resetPassword: (email: string) => Promise<ApiResult<AuthSessionData>>;
+    updatePassword: (password: string) => Promise<ApiResult<AuthSessionData>>;
+    refreshSession: () => Promise<ApiResult<AuthSessionData>>;
+}
+/** Organisation state and methods for unified auth context (ISP). */
+interface UnifiedAuthContextOrganisation {
+    selectedOrganisation: Organisation | null;
+    selectedOrganisationId: string | null;
+    organisations: Organisation[];
+    userMemberships: OrganisationMembership[];
+    organisationLoading: boolean;
+    organisationError: Error | null;
+    hasValidOrganisationContext: boolean;
+    isContextReady: boolean;
+    switchOrganisation: (orgId: string) => Promise<void>;
+    getUserRole: (orgId?: string) => string;
+    validateOrganisationAccess: (orgId: string) => boolean;
+    refreshOrganisations: () => Promise<void>;
+    ensureOrganisationContext: () => Organisation;
+    isOrganisationSecure: () => boolean;
+    getPrimaryOrganisation: () => Organisation | null;
+}
+/** Event state and methods for unified auth context (ISP). */
+interface UnifiedAuthContextEvent {
+    events: Event[];
+    selectedEvent: Event | null;
+    selectedEventId: string | null;
+    eventLoading: boolean;
+    eventError: Error | null;
+    setSelectedEvent: (event: Event | null) => void;
+    refreshEvents: () => Promise<void>;
+}
+/** Inactivity state and methods for unified auth context (ISP). */
+interface UnifiedAuthContextInactivity {
+    showInactivityWarning: boolean;
+    inactivityTimeRemaining: number;
+    isIdle: boolean;
+    timeRemaining: number;
+    showWarning: boolean;
+    isTracking: boolean;
+    resetActivity: () => void;
+    startTracking: () => void;
+    stopTracking: () => void;
+    handleIdleLogout: () => Promise<void>;
+    handleStaySignedIn: () => void;
+    handleSignOutNow: () => Promise<void>;
+}
+/** Unified loading/errors/session restoration (ISP). */
+interface UnifiedAuthContextUnified {
+    isLoading: boolean;
+    hasErrors: boolean;
+    sessionRestoration: SessionRestorationState;
+    sessionRestorationTimedOut: boolean;
+    sessionRestorationTimeoutMs: number;
+}
+/** Unified auth context type (ISP: composed from focused interfaces). */
+type UnifiedAuthContextType = UnifiedAuthContextAuth & UnifiedAuthContextOrganisation & UnifiedAuthContextEvent & UnifiedAuthContextInactivity & UnifiedAuthContextUnified;
+/**
+ * Context for unified authentication.
+ * Provides combined authentication, organisation, event, and inactivity functionality.
+ */
+declare const UnifiedAuthContext: React.Context<UnifiedAuthContextType | undefined>;
+
+/**
+ * @file useUnifiedAuth Hook
+ * @package @jmruthers/pace-core
+ * @module Providers/Services
+ * @since 0.1.0
+ *
+ * Hook to access unified authentication context.
+ */
+
+/**
+ * Hook to access unified authentication context.
+ * Must be used within a UnifiedAuthProvider.
+ *
+ * @returns Unified authentication context
+ * @throws Error if used outside UnifiedAuthProvider
+ */
+declare function useUnifiedAuth(): UnifiedAuthContextType;
+
+/**
+ * User event access interface.
+ * Represents a user's access to a specific event.
+ */
+interface UserEventAccess {
+    event_id: string;
+    event_name: string;
+    event_description?: string | null;
+    start_date: string;
+    end_date: string;
+    event_status: string;
+    app_id: string;
+    access_level: string;
+    granted_at: string;
+    organisation_id: string;
+}
+/**
+ * Props for the UnifiedAuthProvider component.
+ */
+interface UnifiedAuthProviderProps {
+    children: React__default.ReactNode;
+    supabaseClient: SupabaseClient;
+    appName: string;
+    persistState?: boolean;
+    enablePersistence?: boolean;
+    requireOrganisationContext?: boolean;
+    idleTimeoutMs: number;
+    warnBeforeMs: number;
+    onIdleLogout: (reason: 'inactivity') => void;
+    renderInactivityWarning?: (args: {
+        timeRemaining: number;
+        onStaySignedIn: () => void;
+        onSignOutNow: () => void;
+    }) => React__default.ReactNode;
+    dangerouslyDisableInactivity?: boolean;
+}
+/**
+ * Unified authentication provider.
+ * Provides authentication, organisation, event, and inactivity tracking services.
+ *
+ * @param props - Unified auth provider configuration
+ * @returns The unified auth provider
+ */
+declare function UnifiedAuthProvider({ children, supabaseClient, appName, persistState, enablePersistence, requireOrganisationContext, idleTimeoutMs, // REQUIRED: No default - must be explicitly provided
+warnBeforeMs, // REQUIRED: No default - must be explicitly provided
+onIdleLogout, // REQUIRED: No default - must be explicitly provided
+renderInactivityWarning, dangerouslyDisableInactivity }: UnifiedAuthProviderProps): react_jsx_runtime.JSX.Element;
+
+export { type AuthSessionData as A, type IAuthService as I, UnifiedAuthProvider as U, type UnifiedAuthProviderProps as a, type UnifiedAuthContextType as b, type UserEventAccess as c, UnifiedAuthContext as d, useUnifiedAuth as u };

package/dist/api-BZR2CYXL.js

@@ -0,0 +1,5 @@
+export { OrganisationContextRequiredError, clearCache, getAccessLevel, getPageScopeType, getPermissionMap, getRoleContext, hasAllPermissions, hasAnyPermission, invalidateAppCache, invalidateEventCache, invalidateOrganisationCache, invalidateUserCache, isEventAdmin, isOrganisationAdmin, isPermitted, isPermittedCached, isRBACInitialized, isSuperAdmin, resolveAppContext, setupRBAC } from './chunk-7A6IMHH2.js';
+import './chunk-QRYSEPHB.js';
+import './chunk-BTHN5MKC.js';
+import './chunk-44CNXN4P.js';
+import './chunk-3RG5ZIWI.js';

package/dist/api-result-USV1Czr-.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @file API Result Types
+ * @package @jmruthers/pace-core
+ * @module Types/ApiResult
+ * @since 1.0.0
+ *
+ * Standard result shape for async API functions. Ensures consistent error handling
+ * across pace-core and consuming apps. See Architecture and API & Tech Stack standards.
+ */
+/**
+ * Machine-readable error code and user-facing message for API failures.
+ */
+type ApiError = {
+    code: string;
+    message: string;
+    details?: object;
+};
+/**
+ * Type-safe result for async API functions: either success with data or failure with error.
+ */
+type ApiResult<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: ApiError;
+};
+/**
+ * Creates a successful ApiResult.
+ */
+declare function ok<T>(data: T): ApiResult<T>;
+/**
+ * Creates a failed ApiResult.
+ */
+declare function err(error: ApiError): ApiResult<never>;
+/**
+ * Type guard: narrows ApiResult to success variant.
+ */
+declare function isOk<T>(result: ApiResult<T>): result is {
+    ok: true;
+    data: T;
+};
+/**
+ * Type guard: narrows ApiResult to failure variant.
+ */
+declare function isErr<T>(result: ApiResult<T>): result is {
+    ok: false;
+    error: ApiError;
+};
+
+export { type ApiResult as A, type ApiError as a, isErr as b, err as e, isOk as i, ok as o };