@cobaltcore-dev/aurora 0.19.0 → 0.19.1

package/dist/client/App.d.ts

@@ -0,0 +1,12 @@
+import { Slots, OnTrackEventCallback } from './AuroraApp';
+type AppProps = {
+    theme?: "theme-dark" | "theme-light";
+    bffEndpoint?: string;
+    onThemeChange?: (theme: "theme-dark" | "theme-light") => void;
+    slots?: Slots;
+    appName?: string;
+    onTrackEvent?: OnTrackEventCallback;
+    enabledServices?: string[];
+};
+declare const App: (props: AppProps) => import("react/jsx-runtime").JSX.Element;
+export default App;

package/dist/client/analytics/setupRouterAnalytics.d.ts

@@ -0,0 +1,20 @@
+import { createAuroraRouter } from '../router';
+/**
+ * Sets up analytics tracking for router navigation events.
+ * Subscribes to the router's "onResolved" event and emits analytics events
+ * when users navigate between routes. Metadata always includes `pathname`,
+ * includes `search` when query params are present, and includes `section`/`service`
+ * when available via route `staticData`.
+ *
+ * @param router - The TanStack Router instance
+ * @returns Cleanup function to unsubscribe from router events
+ *
+ * @example
+ * ```tsx
+ * const router = createAuroraRouter(trpcReact, trpcClient)
+ * const cleanup = setupRouterAnalytics(router)
+ * // Later, when unmounting:
+ * cleanup()
+ * ```
+ */
+export declare function setupRouterAnalytics(router: ReturnType<typeof createAuroraRouter>): () => void;

package/dist/client/assets/__mocks__/svgMock.d.ts

@@ -0,0 +1,3 @@
+declare const SvgMock: () => null;
+export default SvgMock;
+export { SvgMock as ReactComponent };

package/dist/client/components/Auth/SessionExpirationTimer.d.ts

@@ -0,0 +1,4 @@
+export declare function SessionExpirationTimer(props: {
+    className?: string;
+    sessionExpired: Date;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/ClipboardText.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+export interface ClipboardTextProps extends React.HTMLAttributes<HTMLDivElement> {
+    tooltipContent?: string;
+    text: string;
+    className?: string;
+    truncateAt?: number;
+    showTooltip?: boolean;
+}
+declare const ClipboardText: React.FC<ClipboardTextProps>;
+export default ClipboardText;

package/dist/client/components/ContentHeader/ContentHeader.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+interface ContentHeaderProps {
+    title: string;
+    projectId: string;
+    description?: string | null;
+    actions?: ReactNode;
+    badges?: ReactNode;
+}
+export declare function ContentHeader({ title, projectId, description, actions, badges }: ContentHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/client/components/Error/RouteError.d.ts

@@ -0,0 +1,9 @@
+interface RouteErrorProps {
+    error: unknown;
+    title?: string;
+    helpText?: string;
+    /** Explicitly pass a safe error message to display. Use this when you want to show specific error details. */
+    safeErrorMessage?: string;
+}
+export declare function RouteError({ error, title, helpText, safeErrorMessage }: RouteErrorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/client/components/Error/StatusError.d.ts

@@ -0,0 +1,11 @@
+interface StatusErrorProps {
+    message: string;
+    statusCode?: number;
+    onHomeClick?: () => void;
+    onBackClick?: () => void;
+    title: string;
+    showHeader?: boolean;
+    reset?: () => void;
+}
+export declare function StatusError({ message, statusCode, onHomeClick, onBackClick, title, reset }: StatusErrorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/client/components/JsonEditor.d.ts

@@ -0,0 +1,39 @@
+export interface JsonEditorProps {
+    /** Current JSON string value */
+    value: string;
+    /** Callback when value changes */
+    onChange: (value: string) => void;
+    /** Callback when editor loses focus */
+    onBlur?: () => void;
+    /** Whether the editor is disabled */
+    disabled?: boolean;
+    /** Placeholder text when empty */
+    placeholder?: string;
+    /** Error message to display (also shows error border) */
+    error?: string | null;
+    /** Additional CSS class names (use height classes like h-96 to set fixed height) */
+    className?: string;
+    /** HTML id attribute */
+    id?: string;
+    /** HTML name attribute */
+    name?: string;
+    /** Number of spaces for indentation (default: 2) */
+    indentSize?: number;
+    /** Whether to show line numbers (default: true) */
+    showLineNumbers?: boolean;
+    /** Test ID for testing */
+    "data-testid"?: string;
+}
+/**
+ * A simple JSON editor component with line numbers and smart indentation.
+ *
+ * Features:
+ * - Line numbers
+ * - Tab key inserts spaces
+ * - Enter key auto-indents based on context
+ * - Closing braces/brackets auto-dedent
+ * - Error state styling
+ * - Accessible and keyboard-friendly
+ */
+export declare const JsonEditor: ({ value, onChange, onBlur, disabled, placeholder, error, className, id, name, indentSize, showLineNumbers, "data-testid": testId, }: JsonEditorProps) => import("react/jsx-runtime").JSX.Element;
+export default JsonEditor;

package/dist/client/components/ListToolbar/FiltersInput.d.ts

@@ -0,0 +1,6 @@
+import { Filter, SelectedFilter } from './types';
+export type FiltersInputProps = {
+    filters: Filter[];
+    onChange: (filter: SelectedFilter) => void;
+};
+export declare const FiltersInput: ({ filters, onChange }: FiltersInputProps) => import("react/jsx-runtime").JSX.Element;

package/dist/client/components/ListToolbar/SelectedFilters.d.ts

@@ -0,0 +1,24 @@
+import { SelectedFilter } from './types';
+export type SelectedFiltersProps = {
+    /**
+     * Array of currently active filters to be displayed as closeable pills.
+     */
+    selectedFilters: SelectedFilter[];
+    /**
+     * Callback function invoked when a user removes an individual filter pill.
+     */
+    onDelete: (filter: SelectedFilter) => void;
+    /**
+     * Callback function invoked when the "Clear all" button is clicked.
+     */
+    onClear: () => void;
+};
+/**
+ * SelectedFilters Component
+ *
+ * Displays currently active filters as closeable pill components with individual
+ * remove buttons and an optional "Clear all" button (shown when 2+ filters are active).
+ *
+ * The pills are arranged in a flexible, wrapping layout that adapts to available space.
+ */
+export declare const SelectedFilters: ({ selectedFilters, onDelete, onClear }: SelectedFiltersProps) => import("react/jsx-runtime").JSX.Element;

package/dist/client/components/ListToolbar/SortInput.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { SortOption } from './types';
+export interface SortInputProps {
+    sortBy?: string | number | string[];
+    onSortByChange: (param?: string | number | string[]) => void;
+    sortDirection: "asc" | "desc";
+    onSortDirectionChange: (direction: "asc" | "desc") => void;
+    options: SortOption[];
+    selectClassName?: string;
+}
+export declare const SortInput: React.FC<SortInputProps>;

package/dist/client/components/ListToolbar/index.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { SearchInputProps } from '@cloudoperators/juno-ui-components';
+import { FilterSettings, SortSettings } from './types';
+export type ListToolbarProps = {
+    filterSettings?: FilterSettings;
+    onFilter?: (filterSettings: FilterSettings) => void;
+    sortSettings?: SortSettings;
+    onSort?: (sortSettings: SortSettings) => void;
+    searchTerm?: string;
+    onSearch?: (searchTerm: string) => void;
+    searchInputProps?: Omit<SearchInputProps, "value" | "onSearch" | "onClear" | "onInput">;
+    actions?: ReactNode;
+    tabs?: {
+        items: Array<{
+            label: string;
+            value: string;
+        }>;
+        activeItem: string;
+        onActiveItemChange: (value: ReactNode) => void;
+    };
+    totalCount?: number;
+    itemName?: string;
+    filteredCount?: number;
+    lastUpdated?: Date | string;
+};
+export declare const ListToolbar: ({ filterSettings, onFilter, sortSettings, onSort, searchTerm, onSearch, searchInputProps, actions, tabs, totalCount, filteredCount, itemName, lastUpdated, }: ListToolbarProps) => import("react/jsx-runtime").JSX.Element;

package/dist/client/components/ListToolbar/types.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Represents a single selected filter value in the active filter list
+ * Used to track which filters are currently applied to the data
+ */
+export type SelectedFilter = {
+    /** The filter name/key this selection belongs to (e.g., "status", "visibility") */
+    name: string;
+    /** The selected value for this filter (e.g., "active", "public") */
+    value: string;
+    /**
+     * Whether this filter is temporarily disabled without removing it
+     * Useful for "show/hide" functionality in the UI
+     * @default false
+     */
+    inactive?: boolean;
+};
+/**
+ * Defines a filterable field and its available options
+ * Represents a single filter category that users can apply to narrow down results
+ */
+export type Filter = {
+    /**
+     * Human-readable name shown in the UI
+     * @example "Status", "Visibility", "Disk Format"
+     */
+    displayName: string;
+    /**
+     * The actual parameter name used in API requests
+     * @example "status", "visibility", "disk_format"
+     */
+    filterName: string;
+    /**
+     * Array of available values users can select for this filter
+     * @example ["active", "queued", "saving"] for status filter
+     */
+    values: string[];
+    /**
+     * Whether this filter supports selecting multiple values using the 'in' operator
+     *
+     * For OpenStack Glance API:
+     * - Supports 'in': name, status, id, container_format, disk_format
+     * - Does NOT support 'in': visibility, protected, owner, tags, dates
+     *
+     * When true, multiple selections will be combined as: `filterName=in:value1,value2,value3`
+     * When false, only single value is allowed: `filterName=value`
+     *
+     * @default false
+     * @example
+     * // supportsMultiValue: true
+     * status=in:active,queued,saving
+     *
+     * // supportsMultiValue: false
+     * visibility=public
+     */
+    supportsMultiValue?: boolean;
+};
+/**
+ * Complete filter configuration including available filters and current selections
+ * Represents the entire filtering state for a list view
+ */
+export type FilterSettings = {
+    /**
+     * Currently applied filters by the user
+     * If undefined or empty, no filters are active
+     */
+    selectedFilters?: SelectedFilter[];
+    /**
+     * Available filter definitions that users can choose from
+     * These define what filters are available in the UI
+     */
+    filters: Filter[];
+};
+/**
+ * Represents a single option in the sort dropdown
+ * Defines a field that data can be sorted by
+ */
+export type SortOption = {
+    /**
+     * The actual field name to sort by (used in API requests)
+     * @example "created_at", "name", "size", "status"
+     */
+    value: string;
+    /**
+     * Human-readable label shown in the UI
+     * @example "Created At", "Name", "Size", "Status"
+     */
+    label: string;
+};
+/**
+ * Complete sorting configuration including available options and current sort state
+ * Represents the entire sorting state for a list view
+ */
+export type SortSettings = {
+    /**
+     * Array of available fields that can be used for sorting
+     * These options are displayed in the sort dropdown
+     */
+    options: SortOption[];
+    /**
+     * Currently selected sort field
+     * Can be a string (single field), number (field index), or array (multiple fields)
+     *
+     * For OpenStack Glance API, typically a string representing the field name
+     * @example "created_at", "name", "size"
+     */
+    sortBy?: string | number | string[];
+    /**
+     * Current sort direction
+     *
+     * - "asc": Ascending order (A-Z, 0-9, oldest to newest)
+     * - "desc": Descending order (Z-A, 9-0, newest to oldest)
+     *
+     * @default "desc" (typically for created_at to show newest first)
+     */
+    sortDirection?: "asc" | "desc";
+};

package/dist/client/components/ProjectView/ProjectInfoBox.d.ts

@@ -0,0 +1,12 @@
+interface ProjectInfoBoxProps {
+    projectInfo: {
+        id: string;
+        name: string;
+        description?: string;
+        domain?: {
+            name?: string;
+        };
+    };
+}
+export declare function ProjectInfoBox({ projectInfo }: ProjectInfoBoxProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/client/components/Slot.d.ts

@@ -0,0 +1,7 @@
+import { FC } from 'react';
+import { SlotProps } from '../AuroraApp';
+export declare function Slot({ component: Component, useShadowDOM, currentService, }: {
+    component: FC<SlotProps>;
+    useShadowDOM?: boolean;
+    currentService?: string;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/client/components/navigation/LanguageSelect.d.ts

@@ -0,0 +1,3 @@
+export declare function LanguageSelect({ className }: {
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/navigation/MainNavigation.d.ts

@@ -0,0 +1,10 @@
+import { NavigationItem } from './types';
+import { Slots } from '../../AuroraApp';
+interface NavigationProps {
+    items: NavigationItem[];
+    handleThemeToggle?: (theme: string) => void;
+    appName?: string;
+    slots?: Slots;
+}
+export declare function MainNavigation({ items, handleThemeToggle, appName, slots }: NavigationProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/client/components/navigation/UserMenu.d.ts

@@ -0,0 +1 @@
+export declare function UserMenu(): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/navigation/types.d.ts

@@ -0,0 +1,4 @@
+export interface NavigationItem {
+    route: string;
+    label: string;
+}

package/dist/client/hooks/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * URL-based context hooks
+ *
+ * These hooks extract scope information (projectId, domainId) directly from URL params.
+ * This follows the principle "URL is the source of truth".
+ *
+ * Benefits:
+ * - Centralized URL param extraction (single point of change during route refactoring)
+ * - Type-safe access to route params
+ * - Runtime validation with clear error messages
+ * - No prop drilling needed
+ * - Easy to test and mock
+ */
+export { useProjectId } from './useProjectId';
+export { useDomainId } from './useDomainId';

package/dist/client/hooks/useDomainId.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Get the current user's domain ID from the authentication context.
+ *
+ * This hook provides access to the domain ID of the currently authenticated user.
+ * The domain ID is obtained from the user's session, not from URL parameters.
+ *
+ * @throws {Error} If user is not authenticated or domain ID is not available
+ * @returns {string} The current domain ID from the user's session
+ *
+ * @example
+ * ```tsx
+ * function UsersList() {
+ *   const domainId = useDomainId()
+ *
+ *   const { data } = trpc.identity.users.list.useQuery({
+ *     domain_id: domainId
+ *   })
+ * }
+ * ```
+ */
+export declare function useDomainId(): string;

package/dist/client/hooks/useModalTracking.d.ts

@@ -0,0 +1,33 @@
+interface UseModalTrackingOptions {
+    isOpen: boolean;
+    actionPrefix: string;
+}
+interface UseModalTrackingReturn {
+    trackClose: () => void;
+    markSubmitted: () => void;
+    resetTracking: () => void;
+}
+/**
+ * Custom hook to handle modal open/close analytics tracking.
+ *
+ * Tracks:
+ * - `.open` event when modal opens (once per modal open)
+ * - `.close` event when modal closes without submission (cancelled)
+ *
+ * @example
+ * const { trackClose, markSubmitted, resetTracking } = useModalTracking({
+ *   isOpen,
+ *   actionPrefix: "storage.ceph.bucket.create"
+ * })
+ *
+ * // In handleClose:
+ * trackClose()
+ *
+ * // In handleSubmit:
+ * markSubmitted()
+ *
+ * // In cleanup/reset:
+ * resetTracking()
+ */
+export declare const useModalTracking: ({ isOpen, actionPrefix }: UseModalTrackingOptions) => UseModalTrackingReturn;
+export {};

package/dist/client/hooks/useProjectId.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Extract projectId from the current URL.
+ *
+ * This hook works with both old and new route structures:
+ * - Old: /accounts/:accountId/projects/:projectId/...
+ * - New: /projects/:projectId/...
+ *
+ * @throws {Error} If used outside of a project route context
+ * @returns {string} The current project ID from URL params
+ *
+ * @example
+ * ```tsx
+ * function SecurityGroupsList() {
+ *   const projectId = useProjectId()
+ *
+ *   const { data } = trpc.network.securityGroup.list.useQuery({
+ *     project_id: projectId
+ *   })
+ * }
+ * ```
+ */
+export declare function useProjectId(): string;

package/dist/client/router.d.ts

@@ -0,0 +1,7 @@
+import { TrpcReact, TrpcClient } from './trpcClient';
+export declare function createAuroraRouter(trpcReact: TrpcReact, trpcClient: TrpcClient): import('@tanstack/router-core').RouterCore<import('@tanstack/router-core').Route<import('@tanstack/react-router').Register, any, "/", "/", string, "__root__", undefined, {}, import('./routes/__root').RouterContext, import('@tanstack/router-core').AnyContext, import('@tanstack/router-core').AnyContext, {}, undefined, import('./routeTree.gen').RootRouteChildren, import('./routeTree.gen').FileRouteTypes, unknown, unknown, undefined>, "never", false, import('@tanstack/history').RouterHistory, Record<string, any>>;
+declare module "@tanstack/react-router" {
+    interface Register {
+        router: ReturnType<typeof createAuroraRouter>;
+    }
+}

package/dist/client/store/AuthProvider.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { TokenData } from '../../server/Authentication/types/models';
+export type User = TokenData["user"] | null;
+export interface AuthContext {
+    isAuthenticated: boolean;
+    login: (user: User, expires_at?: string) => Promise<void>;
+    logout: () => Promise<void>;
+    user?: User;
+    expiresAt?: Date;
+}
+interface RouterNavigation {
+    navigate: (options: {
+        to: string;
+        search?: Record<string, unknown>;
+    }) => void;
+    invalidate: () => void;
+}
+export declare function AuthProvider({ children, router }: {
+    children: React.ReactNode;
+    router: RouterNavigation;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useAuth(): AuthContext;
+export {};

package/dist/client/utils/buildFilterParams.d.ts

@@ -0,0 +1,5 @@
+import { FilterSettings } from '../components/ListToolbar/types';
+/**
+ * Builds filter parameters from current filter settings
+ */
+export declare const buildFilterParams: (filterSettings: FilterSettings) => Record<string, string | boolean>;

package/dist/client/utils/cn.d.ts

@@ -0,0 +1,27 @@
+import { ClassValue } from 'clsx';
+/**
+ * A utility function that combines clsx and tailwind-merge
+ *
+ * This function takes multiple class values (strings, objects, arrays, etc.)
+ * and combines them into a single string of CSS classes.
+ * It then uses tailwind-merge to resolve any Tailwind CSS conflicts.
+ *
+ * @param inputs - Class values to be combined
+ * @returns A string of CSS classes with Tailwind conflicts resolved
+ *
+ * @example
+ * // Basic usage
+ * cn('text-red-500', 'bg-blue-500')
+ * // => 'text-red-500 bg-blue-500'
+ *
+ * @example
+ * // With conditionals
+ * cn('text-white', isError && 'bg-red-500', !isError && 'bg-blue-500')
+ * // => 'text-white bg-red-500' or 'text-white bg-blue-500'
+ *
+ * @example
+ * // Resolving conflicts
+ * cn('text-red-500', 'text-blue-500')
+ * // => 'text-blue-500' (the latter class wins)
+ */
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/client/utils/formatBytes.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Supported unit systems for byte formatting.
+ *
+ * - `"binary"` (IEC): uses powers of 1024 → B, KiB, MiB, GiB, TiB, PiB, EiB, ZiB, YiB
+ * - `"decimal"` (SI):  uses powers of 1000 → B, KB, MB, GB, TB, PB, EB, ZB, YB
+ *
+ * Default is `"binary"`.
+ */
+export type ByteUnitSystem = "binary" | "decimal";
+export interface FormatBytesOptions {
+    /** Number of decimal places to display. Defaults to `2`. */
+    decimals?: number;
+    /** Unit system to use. Defaults to `"binary"`. */
+    unitSystem?: ByteUnitSystem;
+}
+/**
+ * Formats a raw byte count into a human-readable string.
+ *
+ * @example
+ * formatBytes(1536)                              // "1.50 KiB"  (binary, default)
+ * formatBytes(1500, { unitSystem: "decimal" })   // "1.50 KB"
+ * formatBytes(1073741824)                        // "1.00 GiB"
+ * formatBytes(0)                                 // "0 B"
+ * formatBytes(null)                              // "0 B"
+ */
+export declare function formatBytes(bytes: number | null | undefined, { decimals, unitSystem }?: FormatBytesOptions): string;
+/**
+ * Convenience wrapper that always uses the decimal (SI) unit system.
+ *
+ * @example
+ * formatBytesDecimal(1500000) // "1.50 MB"
+ */
+export declare const formatBytesDecimal: (bytes: number | null | undefined, decimals?: number) => string;
+/**
+ * Convenience wrapper that always uses the binary (IEC) unit system.
+ *
+ * @example
+ * formatBytesBinary(1048576) // "1.00 MiB"
+ */
+export declare const formatBytesBinary: (bytes: number | null | undefined, decimals?: number) => string;

package/dist/client/utils/formatFloatingIpStatus.d.ts

@@ -0,0 +1,6 @@
+import { FloatingIpStatus } from '../../server/Network/types/floatingIp';
+/**
+ * Formats a floating IP status value from uppercase enum to title case.
+ * Example: "ACTIVE" → "Active", "DOWN" → "Down", "ERROR" → "Error"
+ */
+export declare const formatFloatingIpStatus: (status: FloatingIpStatus) => string;

package/dist/client/utils/languageDetection.d.ts

@@ -0,0 +1,11 @@
+export declare const SUPPORTED_LOCALES: readonly ["en", "de"];
+export type SupportedLocale = (typeof SUPPORTED_LOCALES)[number];
+/**
+ * Detects the user's preferred language with fallback chain:
+ * 1. Saved preference (localStorage)
+ * 2. Browser language settings
+ * 3. Default locale
+ */
+export declare function detectLanguage(): SupportedLocale;
+export declare function saveLanguagePreference(locale: SupportedLocale): void;
+export declare function getLanguagePreference(): SupportedLocale | null;

package/dist/client/utils/trpcErrors.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Type guard to check if an error is a tRPC error with UNAUTHORIZED code
+ */
+export declare function isTRPCUnauthorized(error: unknown): boolean;
+/**
+ * Type guard to check if an error is a tRPC error
+ */
+export declare function isTRPCError(error: unknown): error is {
+    data: {
+        code: string;
+    };
+    message?: string;
+};

package/dist/client/utils/useErrorTranslation.d.ts

@@ -0,0 +1,4 @@
+export declare const useErrorTranslation: () => {
+    translateError: (errorCode: string) => string;
+    isRetryableError: (errorCode: string) => boolean;
+};

package/dist/client/utils/useListWithFiltering.d.ts

@@ -0,0 +1,84 @@
+import { FilterSettings, SortOption, SortSettings } from '../components/ListToolbar/types';
+/**
+ * Sort direction enumeration
+ * Used across all sort-enabled list views
+ */
+export type SortDirection = "asc" | "desc";
+/**
+ * Generic required sort settings with guaranteed non-optional properties
+ * Used by components to maintain a fully-defined sort state
+ *
+ * Type parameter K is the sort key type (string literal union of allowed sort fields)
+ *
+ * @example
+ * // For floating IPs
+ * type FloatingIpListSortSettings = ListSortConfig<FloatingIpsSortKey>
+ *
+ * // For security groups
+ * type SecurityGroupListSortSettings = ListSortConfig<"name" | "project_id">
+ */
+export type ListSortConfig<T extends string = string> = {
+    /**
+     * Array of available sort options to display in the UI
+     */
+    options: SortOption[];
+    /**
+     * The currently selected sort field (guaranteed to be one of the available options)
+     */
+    sortBy: T;
+    /**
+     * The currently active sort direction (guaranteed to be either "asc" or "desc")
+     */
+    sortDirection: SortDirection;
+};
+/**
+ * Configuration options for the useListWithFiltering hook
+ */
+export interface UseListWithFilteringOptions<T extends string> {
+    /** Default sort key to use on initial render */
+    defaultSortKey: T;
+    /** Default sort direction to use on initial render */
+    defaultSortDir: SortDirection;
+    /** Available sort options to display in the sort dropdown */
+    sortOptions: Array<{
+        label: string;
+        value: string;
+    }>;
+    /** Initial filter settings configuration */
+    filterSettings: FilterSettings;
+}
+/**
+ * Return value from the useListWithFiltering hook
+ */
+export interface UseListWithFilteringReturn<T extends string> {
+    searchTerm: string;
+    sortSettings: ListSortConfig<T>;
+    filterSettings: FilterSettings;
+    handleSearchChange: (term: string | number | string[] | undefined) => void;
+    handleSortChange: (newSortSettings: SortSettings) => void;
+    handleFilterChange: (newFilterSettings: FilterSettings) => void;
+}
+/**
+ * Custom hook to manage common list view state: search, sort, and filter
+ *
+ * Extracts shared logic from list components to ensure consistent behavior
+ * across all list pages and reduce code duplication.
+ *
+ * @example
+ * ```tsx
+ * const listState = useListWithFiltering({
+ *   defaultSortKey: "name",
+ *   defaultSortDir: "asc",
+ *   sortOptions: [
+ *     { label: t`Name`, value: "name" },
+ *     { label: t`Created`, value: "created_at" },
+ *   ],
+ *   filterSettings: {
+ *     filters: [
+ *       { displayName: t`Status`, filterName: "status", values: ["active", "inactive"] }
+ *     ]
+ *   }
+ * })
+ * ```
+ */
+export declare function useListWithFiltering<T extends string>({ defaultSortKey, defaultSortDir, sortOptions, filterSettings: initialFilterSettings, }: UseListWithFilteringOptions<T>): UseListWithFilteringReturn<T>;

package/dist/client/utils/useModal.d.ts

@@ -0,0 +1,3 @@
+type UseModalReturn = [boolean, () => void];
+export declare const useModal: (initialState?: boolean) => UseModalReturn;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cobaltcore-dev/aurora",
-  "version": "0.19.0",
+  "version": "0.19.1",
   "private": false,
   "description": "Aurora OpenStack dashboard — server and client library",
   "license": "Apache-2.0",