@j-256/ccam 0.1.0

package/dist/tui/context/terminal-size.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useEffect } from 'react';
+const DEFAULT_SIZE = { cols: 80, rows: 24 };
+function getSize() {
+    const cols = process.stdout.columns;
+    const rows = process.stdout.rows;
+    if (cols && rows)
+        return { cols, rows };
+    return DEFAULT_SIZE;
+}
+const TerminalSizeContext = createContext(DEFAULT_SIZE);
+export function TerminalSizeProvider({ children }) {
+    const [size, setSize] = useState(getSize);
+    useEffect(() => {
+        const onResize = () => setSize(getSize());
+        process.stdout.on('resize', onResize);
+        return () => {
+            process.stdout.off('resize', onResize);
+        };
+    }, []);
+    return _jsx(TerminalSizeContext.Provider, { value: size, children: children });
+}
+export function useTerminalSize() {
+    return useContext(TerminalSizeContext);
+}
+//# sourceMappingURL=terminal-size.js.map

package/dist/tui/format.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Format a user state value with semantic color:
+ * green for ENABLED, red for DELETED, yellow for INITIAL
+ */
+export declare function formatUserState(value: unknown): string;
+/** Format a boolean value: green "Yes" / dim "No" */
+export declare function formatBoolean(value: unknown): string;
+/**
+ * Format a date value: if it looks like an ISO date string, truncate to
+ * just the date portion (YYYY-MM-DD); otherwise return as-is
+ */
+export declare function formatDate(value: unknown): string;
+/**
+ * Format an array value by joining with ', '.
+ * Truncation is handled by the Table component
+ */
+export declare function formatArray(value: unknown): string;
+/** Format a count: if the value is an array, return its length; otherwise stringify */
+export declare function formatCount(value: unknown): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/tui/format.js

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+/**
+ * Format a user state value with semantic color:
+ * green for ENABLED, red for DELETED, yellow for INITIAL
+ */
+export function formatUserState(value) {
+    const s = String(value ?? '');
+    switch (s) {
+        case 'ENABLED':
+            return chalk.green(s);
+        case 'DELETED':
+            return chalk.red(s);
+        case 'INITIAL':
+            return chalk.yellow(s);
+        default:
+            return s;
+    }
+}
+/** Format a boolean value: green "Yes" / dim "No" */
+export function formatBoolean(value) {
+    if (value === true || value === 'true')
+        return chalk.green('Yes');
+    return chalk.dim('No');
+}
+/**
+ * Format a date value: if it looks like an ISO date string, truncate to
+ * just the date portion (YYYY-MM-DD); otherwise return as-is
+ */
+export function formatDate(value) {
+    if (value == null)
+        return '';
+    const s = String(value);
+    // Match ISO-8601 datetime strings (2026-04-14T12:00:00Z etc.)
+    if (/^\d{4}-\d{2}-\d{2}T/.test(s))
+        return s.slice(0, 10);
+    return s;
+}
+/**
+ * Format an array value by joining with ', '.
+ * Truncation is handled by the Table component
+ */
+export function formatArray(value) {
+    if (Array.isArray(value))
+        return value.join(', ');
+    if (value == null)
+        return '';
+    return String(value);
+}
+/** Format a count: if the value is an array, return its length; otherwise stringify */
+export function formatCount(value) {
+    if (Array.isArray(value))
+        return String(value.length);
+    if (value == null)
+        return '';
+    return String(value);
+}
+//# sourceMappingURL=format.js.map

package/dist/tui/hooks/use-audit-log.d.ts

@@ -0,0 +1,12 @@
+import type { ContentResponse, AuditLogRecord } from 'ccam-sdk';
+export declare function useAuditLog(fetchFn: (querySize?: number) => Promise<ContentResponse<AuditLogRecord>>): {
+    loadMore: () => void;
+    confirmLoadAll: () => void;
+    retry: () => void;
+    data: AuditLogRecord[];
+    loading: boolean;
+    error: Error | null;
+    canLoadMore: boolean;
+    needsConfirmation: boolean;
+};
+//# sourceMappingURL=use-audit-log.d.ts.map

package/dist/tui/hooks/use-audit-log.js

@@ -0,0 +1,71 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+const QUERY_SIZE_STEPS = [25, 50, 100];
+export function useAuditLog(fetchFn) {
+    const [state, setState] = useState({
+        data: [],
+        loading: true,
+        error: null,
+        canLoadMore: true,
+        needsConfirmation: false,
+    });
+    const fetchRef = useRef(fetchFn);
+    fetchRef.current = fetchFn;
+    // Track which step index we're on (0=25, 1=50, 2=100)
+    const stepRef = useRef(0);
+    // Track whether all records have been loaded
+    const loadedAllRef = useRef(false);
+    const doFetch = useCallback(async (querySize) => {
+        setState((s) => ({ ...s, loading: true, error: null }));
+        try {
+            const result = await fetchRef.current(querySize);
+            const loadedAll = querySize === undefined;
+            loadedAllRef.current = loadedAll;
+            setState({
+                data: result.content,
+                loading: false,
+                error: null,
+                canLoadMore: !loadedAll,
+                needsConfirmation: !loadedAll && stepRef.current >= QUERY_SIZE_STEPS.length - 1,
+            });
+        }
+        catch (err) {
+            setState((s) => ({
+                ...s,
+                loading: false,
+                error: err instanceof Error ? err : new Error(String(err)),
+            }));
+        }
+    }, []);
+    useEffect(() => {
+        stepRef.current = 0;
+        loadedAllRef.current = false;
+        doFetch(QUERY_SIZE_STEPS[0]);
+    }, [doFetch]);
+    const loadMore = useCallback(() => {
+        if (loadedAllRef.current)
+            return;
+        const nextStep = stepRef.current + 1;
+        if (nextStep < QUERY_SIZE_STEPS.length) {
+            stepRef.current = nextStep;
+            doFetch(QUERY_SIZE_STEPS[nextStep]);
+        }
+        // If already past the last step, loadMore is a no-op;
+        // caller should check needsConfirmation and call confirmLoadAll
+    }, [doFetch]);
+    const confirmLoadAll = useCallback(() => {
+        stepRef.current = QUERY_SIZE_STEPS.length; // past last step
+        doFetch(undefined);
+    }, [doFetch]);
+    const retry = useCallback(() => {
+        stepRef.current = 0;
+        loadedAllRef.current = false;
+        doFetch(QUERY_SIZE_STEPS[0]);
+    }, [doFetch]);
+    return {
+        ...state,
+        loadMore,
+        confirmLoadAll,
+        retry,
+    };
+}
+//# sourceMappingURL=use-audit-log.js.map

package/dist/tui/hooks/use-local-collection.d.ts

@@ -0,0 +1,8 @@
+import type { ContentResponse } from 'ccam-sdk';
+export declare function useLocalCollection<T>(fetchFn: () => Promise<ContentResponse<T>>): {
+    retry: () => Promise<void>;
+    data: T[];
+    loading: boolean;
+    error: Error | null;
+};
+//# sourceMappingURL=use-local-collection.d.ts.map

package/dist/tui/hooks/use-local-collection.js

@@ -0,0 +1,30 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+export function useLocalCollection(fetchFn) {
+    const [state, setState] = useState({
+        data: [],
+        loading: true,
+        error: null,
+    });
+    const fetchRef = useRef(fetchFn);
+    fetchRef.current = fetchFn;
+    const fetch = useCallback(async () => {
+        setState((s) => ({ ...s, loading: true, error: null }));
+        try {
+            const result = await fetchRef.current();
+            setState({ data: result.content, loading: false, error: null });
+        }
+        catch (err) {
+            setState((s) => ({
+                ...s,
+                loading: false,
+                error: err instanceof Error ? err : new Error(String(err)),
+            }));
+        }
+    }, []);
+    useEffect(() => {
+        fetch();
+    }, [fetch]);
+    const retry = useCallback(() => fetch(), [fetch]);
+    return { ...state, retry };
+}
+//# sourceMappingURL=use-local-collection.js.map

package/dist/tui/hooks/use-paginated-resource.d.ts

@@ -0,0 +1,23 @@
+import type { ContentResponse } from 'ccam-sdk';
+import type { SortFieldDef } from '../types.js';
+export interface SortState {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+export declare function usePaginatedResource<T>(fetchFn: (page: number, size: number, sort?: SortState) => Promise<ContentResponse<T>>, size?: number, initialSort?: SortState): {
+    nextPage: () => void;
+    prevPage: () => void;
+    retry: () => void;
+    setSort: (sort: SortState) => void;
+    cycleSort: (sortFields: SortFieldDef[]) => void;
+    reverseSort: () => void;
+    data: T[];
+    page: number;
+    totalPages: number;
+    totalElements: number;
+    loading: boolean;
+    error: Error | null;
+    paginated: boolean;
+    currentSort: SortState | undefined;
+};
+//# sourceMappingURL=use-paginated-resource.d.ts.map

package/dist/tui/hooks/use-paginated-resource.js

@@ -0,0 +1,115 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+function isPagedResponse(r) {
+    return 'page' in r;
+}
+export function usePaginatedResource(fetchFn, size = 25, initialSort) {
+    const [state, setState] = useState({
+        data: [],
+        page: 0,
+        totalPages: 0,
+        totalElements: 0,
+        loading: true,
+        error: null,
+        paginated: false,
+        currentSort: initialSort,
+    });
+    const fetchRef = useRef(fetchFn);
+    fetchRef.current = fetchFn;
+    const stateRef = useRef(state);
+    stateRef.current = state;
+    const fetchPage = useCallback(async (page, sort) => {
+        setState((s) => ({ ...s, loading: true, error: null }));
+        try {
+            const result = await fetchRef.current(page, size, sort);
+            if (isPagedResponse(result)) {
+                setState((s) => ({
+                    data: result.content,
+                    page: result.page.number,
+                    totalPages: result.page.totalPages,
+                    totalElements: result.page.totalElements,
+                    loading: false,
+                    error: null,
+                    paginated: true,
+                    currentSort: s.currentSort,
+                }));
+            }
+            else {
+                setState((s) => ({
+                    data: result.content,
+                    page: 0,
+                    totalPages: 1,
+                    totalElements: result.content.length,
+                    loading: false,
+                    error: null,
+                    paginated: false,
+                    currentSort: s.currentSort,
+                }));
+            }
+        }
+        catch (err) {
+            setState((s) => ({
+                ...s,
+                loading: false,
+                error: err instanceof Error ? err : new Error(String(err)),
+            }));
+        }
+    }, [size]);
+    useEffect(() => {
+        fetchPage(0, initialSort);
+    }, [fetchPage]);
+    const nextPage = useCallback(() => {
+        const s = stateRef.current;
+        if (s.page < s.totalPages - 1)
+            fetchPage(s.page + 1, s.currentSort);
+    }, [fetchPage]);
+    const prevPage = useCallback(() => {
+        const s = stateRef.current;
+        if (s.page > 0)
+            fetchPage(s.page - 1, s.currentSort);
+    }, [fetchPage]);
+    const retry = useCallback(() => {
+        const s = stateRef.current;
+        fetchPage(s.page, s.currentSort);
+    }, [fetchPage]);
+    const setSort = useCallback((sort) => {
+        setState((s) => ({ ...s, currentSort: sort }));
+        fetchPage(0, sort);
+    }, [fetchPage]);
+    const cycleSort = useCallback((sortFields) => {
+        if (sortFields.length === 0)
+            return;
+        const s = stateRef.current;
+        let next;
+        if (!s.currentSort) {
+            next = { field: sortFields[0].field, direction: 'asc' };
+        }
+        else {
+            const idx = sortFields.findIndex((f) => f.field === s.currentSort.field);
+            const nextIdx = (idx + 1) % sortFields.length;
+            next = { field: sortFields[nextIdx].field, direction: 'asc' };
+        }
+        setState((prev) => ({ ...prev, currentSort: next }));
+        fetchPage(0, next);
+    }, [fetchPage]);
+    const reverseSort = useCallback(() => {
+        const s = stateRef.current;
+        if (!s.currentSort)
+            return;
+        const reversed = {
+            field: s.currentSort.field,
+            direction: s.currentSort.direction === 'asc' ? 'desc' : 'asc',
+        };
+        setState((prev) => ({ ...prev, currentSort: reversed }));
+        fetchPage(0, reversed);
+    }, [fetchPage]);
+    return {
+        ...state,
+        nextPage,
+        prevPage,
+        retry,
+        setSort,
+        cycleSort,
+        reverseSort,
+    };
+}
+//# sourceMappingURL=use-paginated-resource.js.map

package/dist/tui/hooks/use-resource-detail.d.ts

@@ -0,0 +1,7 @@
+export declare function useResourceDetail<T>(fetchFn: () => Promise<T>): {
+    retry: () => Promise<void>;
+    data: T | null;
+    loading: boolean;
+    error: Error | null;
+};
+//# sourceMappingURL=use-resource-detail.d.ts.map

package/dist/tui/hooks/use-resource-detail.js

@@ -0,0 +1,30 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+export function useResourceDetail(fetchFn) {
+    const [state, setState] = useState({
+        data: null,
+        loading: true,
+        error: null,
+    });
+    const fetchRef = useRef(fetchFn);
+    fetchRef.current = fetchFn;
+    const fetch = useCallback(async () => {
+        setState((s) => ({ ...s, loading: true, error: null }));
+        try {
+            const data = await fetchRef.current();
+            setState({ data, loading: false, error: null });
+        }
+        catch (err) {
+            setState((s) => ({
+                ...s,
+                loading: false,
+                error: err instanceof Error ? err : new Error(String(err)),
+            }));
+        }
+    }, []);
+    useEffect(() => {
+        fetch();
+    }, [fetch]);
+    const retry = useCallback(() => fetch(), [fetch]);
+    return { ...state, retry };
+}
+//# sourceMappingURL=use-resource-detail.js.map

package/dist/tui/hooks/use-scroll-window.d.ts

@@ -0,0 +1,7 @@
+export interface ScrollWindow {
+    scrollOffset: number;
+    visibleRows: number;
+    scrollInfo: string | undefined;
+}
+export declare function useScrollWindow(highlightIndex: number, totalRows: number, visibleRows?: number): ScrollWindow;
+//# sourceMappingURL=use-scroll-window.d.ts.map

package/dist/tui/hooks/use-scroll-window.js

@@ -0,0 +1,29 @@
+import { useRef } from 'react';
+import { useTerminalSize } from '../context/terminal-size.js';
+const CHROME_LINES = 12; // header bar (3) + data-area borders (2) + section title (1) + table header+sep (2) + footer bar (4)
+const MIN_VISIBLE = 5;
+export function useScrollWindow(highlightIndex, totalRows, visibleRows) {
+    const offsetRef = useRef(0);
+    const termSize = useTerminalSize();
+    const rows = visibleRows ?? Math.max(MIN_VISIBLE, termSize.rows - CHROME_LINES);
+    if (totalRows <= rows) {
+        offsetRef.current = 0;
+        return { scrollOffset: 0, visibleRows: rows, scrollInfo: undefined };
+    }
+    let offset = offsetRef.current;
+    if (highlightIndex < offset) {
+        offset = highlightIndex;
+    }
+    else if (highlightIndex >= offset + rows) {
+        offset = highlightIndex - rows + 1;
+    }
+    offset = Math.max(0, Math.min(offset, totalRows - rows));
+    offsetRef.current = offset;
+    const end = Math.min(offset + rows, totalRows);
+    return {
+        scrollOffset: offset,
+        visibleRows: rows,
+        scrollInfo: `Rows ${offset + 1}-${end} of ${totalRows}`,
+    };
+}
+//# sourceMappingURL=use-scroll-window.js.map

package/dist/tui/index.d.ts

@@ -0,0 +1,2 @@
+export declare function startTui(): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/tui/index.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { App } from './App.js';
+import { resolveProfile } from '../auth/profile-resolver.js';
+import { createClientFromResolved } from '../client-factory.js';
+import { handleError } from '../error-handler.js';
+export async function startTui() {
+    let client;
+    let host;
+    try {
+        const resolved = await resolveProfile({ flags: {} });
+        client = await createClientFromResolved(resolved);
+        host = resolved.host;
+    }
+    catch (err) {
+        handleError(err);
+    }
+    process.stderr.write('Starting interactive TUI. Press `q` to quit, or run `ccam --help` for the CLI.\n');
+    const { waitUntilExit } = render(_jsx(App, { client: client, host: host }), { alternateScreen: true });
+    await waitUntilExit();
+}
+//# sourceMappingURL=index.js.map

package/dist/tui/navigation.d.ts

@@ -0,0 +1,11 @@
+import type { ViewEntry } from './types.js';
+export interface NavStack {
+    stack: ViewEntry[];
+    current: ViewEntry;
+    breadcrumbs: string[];
+    canGoBack: boolean;
+}
+export declare function createNavStack(initial: ViewEntry): NavStack;
+export declare function pushNav(state: NavStack, entry: ViewEntry): NavStack;
+export declare function popNav(state: NavStack): NavStack;
+//# sourceMappingURL=navigation.d.ts.map

package/dist/tui/navigation.js

@@ -0,0 +1,29 @@
+export function createNavStack(initial) {
+    return {
+        stack: [initial],
+        current: initial,
+        breadcrumbs: [initial.label],
+        canGoBack: false,
+    };
+}
+export function pushNav(state, entry) {
+    const stack = [...state.stack, entry];
+    return {
+        stack,
+        current: entry,
+        breadcrumbs: stack.map((e) => e.label),
+        canGoBack: true,
+    };
+}
+export function popNav(state) {
+    if (state.stack.length <= 1)
+        return state;
+    const stack = state.stack.slice(0, -1);
+    return {
+        stack,
+        current: stack[stack.length - 1],
+        breadcrumbs: stack.map((e) => e.label),
+        canGoBack: stack.length > 1,
+    };
+}
+//# sourceMappingURL=navigation.js.map

package/dist/tui/resource-configs/api-clients.d.ts

@@ -0,0 +1,3 @@
+import type { ResourceConfig } from '../types.js';
+export declare const apiClientsConfig: ResourceConfig;
+//# sourceMappingURL=api-clients.d.ts.map

package/dist/tui/resource-configs/api-clients.js

@@ -0,0 +1,118 @@
+import { ApiClientSortField } from 'ccam-sdk';
+import { formatBoolean, formatDate, formatArray } from '../format.js';
+export const apiClientsConfig = {
+    name: 'client',
+    displayName: 'API Clients',
+    idField: 'id',
+    // -- List view --
+    columns: [
+        { key: 'name', label: 'Name', width: 4, color: 'white', sort: { mode: 'remote', field: ApiClientSortField.NAME } },
+        { key: 'id', label: 'ID', width: 4, priority: 5, color: 'gray', sort: { mode: 'remote', field: ApiClientSortField.ID } },
+        { key: 'active', label: 'Active', width: 1, format: formatBoolean, sort: { mode: 'remote', field: ApiClientSortField.ACTIVE } },
+        {
+            key: 'tokenEndpointAuthMethod',
+            label: 'Auth Method',
+            width: 2,
+            priority: 3,
+            color: 'magenta',
+            sort: { mode: 'remote', field: ApiClientSortField.TOKEN_ENDPOINT_AUTH_METHOD },
+        },
+        { key: 'createdAt', label: 'Created', width: 2, format: formatDate, priority: 3, color: 'blue', sort: { mode: 'remote', field: ApiClientSortField.CREATED_AT } },
+    ],
+    listFn: (c, opts) => c.apiClients.list({
+        page: opts.page,
+        size: opts.size,
+        sort: opts.sort ? { field: opts.sort.field, direction: opts.sort.direction } : undefined,
+    }),
+    labelFn: (item) => item.name || item.id || 'API Client',
+    detailFn: (c, id) => c.apiClients.get(id),
+    // -- Detail view --
+    fields: [
+        { key: 'name', label: 'Name', group: 'identity' },
+        { key: 'description', label: 'Description', group: 'identity' },
+        { key: 'id', label: 'ID', group: 'identity' },
+        { key: 'scopes', label: 'Scopes', format: formatArray, group: 'config' },
+        { key: 'defaultScopes', label: 'Default Scopes', format: formatArray, group: 'config' },
+        { key: 'redirectUrls', label: 'Redirect URLs', format: formatArray, group: 'config' },
+        { key: 'jwtPublicKey', label: 'JWT Public Key', group: 'config' },
+        { key: 'organizationCount', label: 'Organization Count', group: 'status' },
+        { key: 'active', label: 'Active', format: formatBoolean, group: 'status' },
+        { key: 'publicClient', label: 'Public Client', format: formatBoolean, group: 'status' },
+        { key: 'tokenEndpointAuthMethod', label: 'Auth Method', group: 'status' },
+        { key: 'passwordModificationTimestamp', label: 'Password Modified', group: 'status' },
+        { key: 'lastAuthenticatedDate', label: 'Last Authenticated', format: formatDate, group: 'status' },
+        { key: 'disabledTimestamp', label: 'Disabled', format: formatDate, group: 'status' },
+        { key: 'createdAt', label: 'Created', format: formatDate, group: 'status' },
+        { key: 'needsInitialPassword', label: 'Needs Initial Password', format: formatBoolean, group: 'status' },
+    ],
+    tabs: [
+        {
+            key: 'organizations',
+            label: 'Organizations',
+            type: 'local',
+            fetchFn: (c, id) => c.apiClients.get(id, { expand: 'organizations' }).then((client) => ({
+                content: client.organizations || [],
+                links: [],
+            })),
+            columns: [
+                { key: 'name', label: 'Name', width: 5 },
+                { key: 'type', label: 'Type', width: 2 },
+                { key: 'twoFAEnabled', label: '2FA', width: 1, format: formatBoolean },
+            ],
+            crossLinkTo: 'org-detail',
+        },
+        {
+            key: 'roles',
+            label: 'Roles',
+            type: 'local',
+            fetchFn: (c, id) => c.apiClients.get(id, { expand: 'roles' }).then((client) => ({
+                content: client.roles || [],
+                links: [],
+            })),
+            columns: [
+                { key: 'id', label: 'ID', width: 3 },
+                { key: 'description', label: 'Description', width: 5 },
+                { key: 'scope', label: 'Scope', width: 1 },
+                { key: 'targetType', label: 'Target', width: 1 },
+            ],
+            crossLinkTo: 'role-detail',
+        },
+        {
+            key: 'assignedRealms',
+            label: 'Assigned Realms',
+            type: 'local',
+            fetchFn: (c, id) => c.apiClients.assignedRealms(id),
+            columns: [
+                { key: 'id', label: 'ID', width: 1 },
+                { key: 'description', label: 'Description', width: 3 },
+                { key: 'customerName', label: 'Customer', width: 3 },
+            ],
+            crossLinkTo: 'realm-detail',
+        },
+        {
+            key: 'assignedInstances',
+            label: 'Assigned Instances',
+            type: 'local',
+            fetchFn: (c, id) => c.apiClients.assignedInstances(id),
+            columns: [
+                { key: 'id', label: 'ID', width: 2 },
+                { key: 'description', label: 'Description', width: 5 },
+            ],
+            crossLinkTo: 'instance-detail',
+        },
+        {
+            key: 'audit',
+            label: 'Audit',
+            type: 'audit',
+            fetchFn: (c, id, querySize) => c.apiClients.auditLogs(id, querySize !== undefined ? { querySize } : undefined),
+            columns: [
+                { key: 'timestamp', label: 'Time', width: 2, format: formatDate },
+                { key: 'eventType', label: 'Event', width: 2 },
+                { key: 'eventMessage', label: 'Message', width: 4 },
+                { key: 'authorDisplayName', label: 'Author', width: 2 },
+            ],
+        },
+    ],
+    crossLinks: [],
+};
+//# sourceMappingURL=api-clients.js.map

package/dist/tui/resource-configs/index.d.ts

@@ -0,0 +1,14 @@
+import type { ResourceConfig } from '../types.js';
+import { usersConfig } from './users.js';
+import { organizationsConfig } from './organizations.js';
+import { apiClientsConfig } from './api-clients.js';
+import { rolesConfig } from './roles.js';
+import { realmsConfig } from './realms.js';
+import { instancesConfig } from './instances.js';
+import { permissionsConfig } from './permissions.js';
+import { serviceTypesConfig } from './service-types.js';
+import { orgConfigurationConfig } from './org-configuration.js';
+export declare const RESOURCE_CONFIGS: Record<string, ResourceConfig>;
+export declare function getResourceConfig(name: string): ResourceConfig;
+export { usersConfig, organizationsConfig, apiClientsConfig, rolesConfig, realmsConfig, instancesConfig, permissionsConfig, serviceTypesConfig, orgConfigurationConfig, };
+//# sourceMappingURL=index.d.ts.map