@wakastellar/ui 2.1.2 → 2.3.2

package/dist/components/waka-ad-interstitial/index.d.ts

@@ -0,0 +1,26 @@
+export interface WakaAdInterstitialProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Whether the interstitial is open */
+    open: boolean;
+    /** Callback when closed */
+    onClose: () => void;
+    /** Minimum display time before close button appears (seconds) */
+    minDisplayTime?: number;
+    /** Auto-close after duration (seconds, 0 = manual close only) */
+    autoCloseAfter?: number;
+    /** GPT ad unit path */
+    adUnitPath?: string;
+    /** Show countdown timer */
+    showCountdown?: boolean;
+    /** Skip button text */
+    skipText?: string;
+    /** Custom class name */
+    className?: string;
+    /** Callback when ad loads */
+    onLoad?: () => void;
+    /** Callback when ad is clicked */
+    onClick?: () => void;
+}
+export declare function WakaAdInterstitial({ slotId, open, onClose, minDisplayTime, autoCloseAfter, adUnitPath, showCountdown, skipText, className, onLoad, onClick, }: WakaAdInterstitialProps): import("react/jsx-runtime").JSX.Element | null;
+export default WakaAdInterstitial;

package/dist/components/waka-ad-placeholder/index.d.ts

@@ -0,0 +1,17 @@
+import { AdSize } from '../waka-ad-provider';
+export interface WakaAdPlaceholderProps {
+    /** Ad size preset */
+    size?: AdSize;
+    /** Width in pixels (overrides size) */
+    width?: number;
+    /** Height in pixels (overrides size) */
+    height?: number;
+    /** Show animated skeleton */
+    animated?: boolean;
+    /** Show label text */
+    showLabel?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaAdPlaceholder({ size, width, height, animated, showLabel, className, }: WakaAdPlaceholderProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdPlaceholder;

package/dist/components/waka-ad-provider/index.d.ts

@@ -0,0 +1,103 @@
+import * as React from "react";
+export type AdNetwork = "gpt" | "custom" | "adsense";
+export type AdSize = "leaderboard" | "rectangle" | "skyscraper" | "billboard" | "mobile-banner" | "custom";
+export type AdPosition = "top" | "bottom" | "sidebar" | "inline" | "interstitial" | "sticky";
+export interface AdSlot {
+    id: string;
+    network: AdNetwork;
+    size: AdSize;
+    position: AdPosition;
+    targeting?: Record<string, string | string[]>;
+    refreshInterval?: number;
+    lazyLoad?: boolean;
+    customWidth?: number;
+    customHeight?: number;
+}
+export interface AdConfig {
+    network: AdNetwork;
+    publisherId?: string;
+    gptNetworkCode?: string;
+    gptAdUnits?: Record<string, string>;
+    customAdServer?: string;
+    customApiKey?: string;
+    enableLazyLoad?: boolean;
+    lazyLoadOffset?: number;
+    enableRefresh?: boolean;
+    defaultRefreshInterval?: number;
+    enableConsent?: boolean;
+    testMode?: boolean;
+    debugMode?: boolean;
+}
+export interface AdEvent {
+    type: "impression" | "click" | "viewable" | "error" | "loaded" | "empty";
+    slotId: string;
+    timestamp: Date;
+    data?: Record<string, unknown>;
+}
+export interface CustomAd {
+    id: string;
+    imageUrl?: string;
+    videoUrl?: string;
+    targetUrl: string;
+    title?: string;
+    description?: string;
+    sponsor?: string;
+    cta?: string;
+    trackingPixels?: string[];
+    impressionUrl?: string;
+    clickUrl?: string;
+}
+interface AdContextValue {
+    config: AdConfig;
+    isReady: boolean;
+    hasConsent: boolean | null;
+    setConsent: (consent: boolean) => void;
+    registerSlot: (slot: AdSlot) => void;
+    unregisterSlot: (slotId: string) => void;
+    refreshSlot: (slotId: string) => void;
+    refreshAll: () => void;
+    getCustomAd: (slotId: string) => Promise<CustomAd | null>;
+    trackEvent: (event: AdEvent) => void;
+    slots: Map<string, AdSlot>;
+}
+export declare const AD_SIZES: Record<AdSize, {
+    width: number;
+    height: number;
+    label: string;
+}>;
+export declare function useAdContext(): AdContextValue;
+export declare function useAdVisibility(ref: React.RefObject<HTMLElement>, threshold?: number): {
+    isVisible: boolean;
+    viewableTime: number;
+};
+export declare function useAdConsent(): {
+    hasConsent: boolean | null;
+    setConsent: (consent: boolean) => void;
+};
+export declare function useAdSlot(slot: AdSlot): {
+    refresh: () => void;
+    isReady: boolean;
+};
+interface WakaAdProviderProps {
+    children: React.ReactNode;
+    config: AdConfig;
+    onEvent?: (event: AdEvent) => void;
+}
+export declare function WakaAdProvider({ children, config, onEvent }: WakaAdProviderProps): import("react/jsx-runtime").JSX.Element;
+declare global {
+    interface Window {
+        googletag: {
+            cmd: Array<() => void>;
+            defineSlot: (adUnitPath: string, size: [number, number], divId: string) => unknown;
+            pubads: () => {
+                enableSingleRequest: () => void;
+                enableLazyLoad: (config: Record<string, unknown>) => void;
+                refresh: () => void;
+                setTargeting: (key: string, value: string | string[]) => void;
+            };
+            enableServices: () => void;
+            display: (divId: string) => void;
+        };
+    }
+}
+export default WakaAdProvider;

package/dist/components/waka-ad-sidebar/index.d.ts

@@ -0,0 +1,18 @@
+import { WakaAdBannerProps } from '../waka-ad-banner';
+export interface WakaAdSidebarProps extends Omit<WakaAdBannerProps, "size"> {
+    /** Enable sticky behavior */
+    sticky?: boolean;
+    /** Top offset when sticky (in pixels) */
+    stickyOffset?: number;
+    /** Bottom boundary element selector */
+    boundarySelector?: string;
+    /** Gap between multiple ads */
+    gap?: number;
+    /** Additional ads to show below */
+    additionalSlots?: Array<{
+        slotId: string;
+        adUnitPath?: string;
+    }>;
+}
+export declare function WakaAdSidebar({ slotId, sticky, stickyOffset, boundarySelector, gap, additionalSlots, className, ...bannerProps }: WakaAdSidebarProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdSidebar;

package/dist/components/waka-ad-sticky-footer/index.d.ts

@@ -0,0 +1,17 @@
+import { WakaAdBannerProps } from '../waka-ad-banner';
+export interface WakaAdStickyFooterProps extends Omit<WakaAdBannerProps, "size"> {
+    /** Allow user to dismiss */
+    dismissable?: boolean;
+    /** Show close button after delay (seconds) */
+    showCloseAfter?: number;
+    /** Animation style */
+    animation?: "slide" | "fade" | "none";
+    /** Safe area padding (for mobile notches) */
+    safeAreaPadding?: boolean;
+    /** Background blur */
+    blur?: boolean;
+    /** Container class name */
+    containerClassName?: string;
+}
+export declare function WakaAdStickyFooter({ slotId, dismissable, showCloseAfter, animation, safeAreaPadding, blur, className, containerClassName, ...bannerProps }: WakaAdStickyFooterProps): import("react/jsx-runtime").JSX.Element | null;
+export default WakaAdStickyFooter;

package/dist/components/waka-alert-panel/index.d.ts

@@ -0,0 +1,45 @@
+export type AlertSeverity = "critical" | "warning" | "info";
+export type AlertStatus = "firing" | "acknowledged" | "resolved" | "silenced";
+export interface Alert {
+    id: string;
+    title: string;
+    description?: string;
+    severity: AlertSeverity;
+    status: AlertStatus;
+    source: string;
+    startedAt: Date;
+    endedAt?: Date;
+    acknowledgedAt?: Date;
+    acknowledgedBy?: string;
+    silencedUntil?: Date;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+    fingerprint?: string;
+    runbookUrl?: string;
+}
+export interface WakaAlertPanelProps {
+    /** List of alerts */
+    alerts: Alert[];
+    /** Callback when acknowledging an alert */
+    onAcknowledge?: (alertId: string) => void;
+    /** Callback when silencing an alert */
+    onSilence?: (alertId: string, duration: number) => void;
+    /** Callback when resolving an alert */
+    onResolve?: (alertId: string) => void;
+    /** Callback when viewing alert details */
+    onViewDetails?: (alert: Alert) => void;
+    /** Callback when clicking runbook link */
+    onRunbook?: (alert: Alert) => void;
+    /** Callback when refreshing alerts */
+    onRefresh?: () => void;
+    /** Whether alerts are loading */
+    isLoading?: boolean;
+    /** Show resolved alerts */
+    showResolved?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Title */
+    title?: string;
+}
+export declare function WakaAlertPanel({ alerts, onAcknowledge, onSilence, onResolve, onViewDetails, onRunbook, onRefresh, isLoading, showResolved, className, title, }: WakaAlertPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultAlerts: Alert[];

package/dist/components/waka-artifact-list/index.d.ts

@@ -0,0 +1,32 @@
+export interface Artifact {
+    id: string;
+    name: string;
+    type: "archive" | "binary" | "log" | "report" | "image" | "other";
+    size: number;
+    createdAt: Date;
+    expiresAt?: Date;
+    downloadUrl?: string;
+    sha256?: string;
+    buildId?: string;
+    metadata?: Record<string, string>;
+}
+export interface WakaArtifactListProps {
+    /** List of artifacts */
+    artifacts: Artifact[];
+    /** Callback when downloading an artifact */
+    onDownload?: (artifact: Artifact) => void;
+    /** Callback when deleting an artifact */
+    onDelete?: (artifact: Artifact) => void;
+    /** Callback when viewing artifact details */
+    onView?: (artifact: Artifact) => void;
+    /** Title */
+    title?: string;
+    /** Show expiration */
+    showExpiration?: boolean;
+    /** Allow deletion */
+    allowDelete?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaArtifactList({ artifacts, onDownload, onDelete, onView, title, showExpiration, allowDelete, className, }: WakaArtifactListProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultArtifacts: Artifact[];

package/dist/components/waka-build-matrix/index.d.ts

@@ -0,0 +1,36 @@
+export type BuildStatus = "success" | "failed" | "running" | "pending" | "skipped" | "cancelled";
+export interface BuildCell {
+    id: string;
+    status: BuildStatus;
+    duration?: number;
+    startedAt?: Date;
+    finishedAt?: Date;
+    url?: string;
+    logs?: string;
+}
+export interface BuildMatrixRow {
+    label: string;
+    description?: string;
+    cells: BuildCell[];
+}
+export interface WakaBuildMatrixProps {
+    /** Column headers (e.g., OS names or versions) */
+    columns: string[];
+    /** Row data with cells */
+    rows: BuildMatrixRow[];
+    /** Callback when clicking on a cell */
+    onCellClick?: (rowIndex: number, colIndex: number, cell: BuildCell) => void;
+    /** Callback when retrying a build */
+    onRetry?: (rowIndex: number, colIndex: number) => void;
+    /** Callback when viewing logs */
+    onViewLogs?: (cell: BuildCell) => void;
+    /** Title of the matrix */
+    title?: string;
+    /** Show duration in cells */
+    showDuration?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaBuildMatrix({ columns, rows, onCellClick, onRetry, onViewLogs, title, showDuration, className, }: WakaBuildMatrixProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultBuildMatrixColumns: string[];
+export declare const defaultBuildMatrixRows: BuildMatrixRow[];

package/dist/components/waka-config-comparator/index.d.ts

@@ -0,0 +1,37 @@
+export interface ConfigValue {
+    key: string;
+    value: string | number | boolean | null;
+    type?: "string" | "number" | "boolean" | "null";
+}
+export interface ConfigEnvironment {
+    id: string;
+    name: string;
+    values: ConfigValue[];
+}
+export type DiffType = "added" | "removed" | "modified" | "unchanged";
+export interface ConfigDiff {
+    key: string;
+    leftValue?: string | number | boolean | null;
+    rightValue?: string | number | boolean | null;
+    diffType: DiffType;
+}
+export interface WakaConfigComparatorProps {
+    /** List of environments to compare */
+    environments: ConfigEnvironment[];
+    /** Left environment ID */
+    leftEnvId?: string;
+    /** Right environment ID */
+    rightEnvId?: string;
+    /** Callback when environment selection changes */
+    onEnvironmentChange?: (left: string, right: string) => void;
+    /** Callback when copying value */
+    onCopyValue?: (key: string, value: unknown, fromEnv: string, toEnv: string) => void;
+    /** Show only differences */
+    showDiffsOnly?: boolean;
+    /** Title */
+    title?: string;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaConfigComparator({ environments, leftEnvId: initialLeftId, rightEnvId: initialRightId, onEnvironmentChange, onCopyValue, showDiffsOnly: initialShowDiffsOnly, title, className, }: WakaConfigComparatorProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultConfigEnvironments: ConfigEnvironment[];

package/dist/components/waka-container-list/index.d.ts

@@ -0,0 +1,51 @@
+export type ContainerStatus = "running" | "stopped" | "paused" | "restarting" | "exited" | "created";
+export interface ContainerResource {
+    cpu: number;
+    memory: number;
+    memoryLimit: number;
+    networkRx: number;
+    networkTx: number;
+}
+export interface Container {
+    id: string;
+    name: string;
+    image: string;
+    status: ContainerStatus;
+    createdAt: Date;
+    startedAt?: Date;
+    ports?: Array<{
+        host: number;
+        container: number;
+        protocol: string;
+    }>;
+    resources?: ContainerResource;
+    labels?: Record<string, string>;
+    command?: string;
+    exitCode?: number;
+}
+export interface WakaContainerListProps {
+    /** List of containers */
+    containers: Container[];
+    /** Callback when starting a container */
+    onStart?: (containerId: string) => void;
+    /** Callback when stopping a container */
+    onStop?: (containerId: string) => void;
+    /** Callback when restarting a container */
+    onRestart?: (containerId: string) => void;
+    /** Callback when removing a container */
+    onRemove?: (containerId: string) => void;
+    /** Callback when viewing logs */
+    onViewLogs?: (containerId: string) => void;
+    /** Callback when opening terminal */
+    onExec?: (containerId: string) => void;
+    /** Callback when refreshing */
+    onRefresh?: () => void;
+    /** Whether data is loading */
+    isLoading?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Title */
+    title?: string;
+}
+export declare function WakaContainerList({ containers, onStart, onStop, onRestart, onRemove, onViewLogs, onExec, onRefresh, isLoading, className, title, }: WakaContainerListProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultContainers: Container[];

package/dist/components/waka-content-recommendation/index.d.ts

@@ -0,0 +1,23 @@
+export type RecommendationLayout = "grid" | "carousel" | "list";
+export interface WakaContentRecommendationProps {
+    /** Widget title */
+    title?: string;
+    /** Slot IDs for recommendations */
+    slotIds: string[];
+    /** Layout style */
+    layout?: RecommendationLayout;
+    /** Number of columns for grid layout */
+    columns?: 2 | 3 | 4;
+    /** Show navigation arrows for carousel */
+    showArrows?: boolean;
+    /** Auto-scroll carousel */
+    autoScroll?: boolean;
+    /** Auto-scroll interval (seconds) */
+    autoScrollInterval?: number;
+    /** Custom class name */
+    className?: string;
+    /** Callback when item is clicked */
+    onItemClick?: (slotId: string) => void;
+}
+export declare function WakaContentRecommendation({ title, slotIds, layout, columns, showArrows, autoScroll, autoScrollInterval, className, onItemClick, }: WakaContentRecommendationProps): import("react/jsx-runtime").JSX.Element | null;
+export default WakaContentRecommendation;

package/dist/components/waka-database-card/index.d.ts

@@ -0,0 +1,46 @@
+export type DatabaseType = "postgresql" | "mysql" | "mongodb" | "redis" | "elasticsearch" | "other";
+export type DatabaseStatus = "healthy" | "warning" | "critical" | "offline" | "syncing";
+export type ReplicationRole = "primary" | "replica" | "standalone";
+export interface DatabaseMetrics {
+    connectionsActive: number;
+    connectionsMax: number;
+    queriesPerSecond: number;
+    slowQueries: number;
+    avgQueryTime: number;
+    cacheHitRate?: number;
+    storageUsed: number;
+    storageTotal: number;
+    replicationLag?: number;
+    uptime?: number;
+}
+export interface DatabaseInfo {
+    id: string;
+    name: string;
+    type: DatabaseType;
+    version?: string;
+    host: string;
+    port: number;
+    status: DatabaseStatus;
+    role: ReplicationRole;
+    metrics: DatabaseMetrics;
+    replicas?: number;
+    lastBackup?: Date;
+    tags?: string[];
+}
+export interface WakaDatabaseCardProps {
+    /** Database info */
+    database: DatabaseInfo;
+    /** Callback when clicking refresh */
+    onRefresh?: () => void;
+    /** Callback when clicking on the database */
+    onClick?: () => void;
+    /** Show detailed metrics */
+    detailed?: boolean;
+    /** Compact mode */
+    compact?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaDatabaseCard({ database, onRefresh, onClick, detailed, compact, className, }: WakaDatabaseCardProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultDatabase: DatabaseInfo;
+export declare const defaultDatabases: DatabaseInfo[];

package/dist/components/waka-dependency-tree/index.d.ts

@@ -0,0 +1,38 @@
+export type DependencyType = "direct" | "transitive" | "dev" | "peer" | "optional";
+export type VulnSeverity = "critical" | "high" | "medium" | "low" | "none";
+export interface Dependency {
+    id: string;
+    name: string;
+    version: string;
+    latestVersion?: string;
+    type: DependencyType;
+    license?: string;
+    vulnerabilities?: {
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+    };
+    outdated?: boolean;
+    children?: Dependency[];
+    size?: number;
+    repository?: string;
+}
+export interface WakaDependencyTreeProps {
+    /** Root dependencies */
+    dependencies: Dependency[];
+    /** Callback when clicking on a dependency */
+    onDependencyClick?: (dep: Dependency) => void;
+    /** Callback when upgrading a dependency */
+    onUpgrade?: (dep: Dependency) => void;
+    /** Title */
+    title?: string;
+    /** Show dev dependencies */
+    showDevDeps?: boolean;
+    /** Show only vulnerable */
+    showVulnerableOnly?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaDependencyTree({ dependencies, onDependencyClick, onUpgrade, title, showDevDeps, showVulnerableOnly, className, }: WakaDependencyTreeProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultDependencies: Dependency[];

package/dist/components/waka-env-var-editor/index.d.ts

@@ -0,0 +1,30 @@
+export interface EnvVariable {
+    key: string;
+    value: string;
+    isSecret?: boolean;
+    isRequired?: boolean;
+    description?: string;
+    source?: string;
+}
+export interface WakaEnvVarEditorProps {
+    /** List of environment variables */
+    variables: EnvVariable[];
+    /** Callback when variables change */
+    onChange?: (variables: EnvVariable[]) => void;
+    /** Callback when saving */
+    onSave?: (variables: EnvVariable[]) => void;
+    /** Callback when importing */
+    onImport?: (content: string) => void;
+    /** Callback when exporting */
+    onExport?: () => void;
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Show source column */
+    showSource?: boolean;
+    /** Title */
+    title?: string;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaEnvVarEditor({ variables: initialVariables, onChange, onSave, onImport, onExport, readOnly, showSource, title, className, }: WakaEnvVarEditorProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultEnvVariables: EnvVariable[];

package/dist/components/waka-feature-flag-row/index.d.ts

@@ -0,0 +1,45 @@
+export type FeatureFlagStatus = "enabled" | "disabled" | "percentage" | "segment";
+export interface FeatureFlagSegment {
+    id: string;
+    name: string;
+    description?: string;
+}
+export interface FeatureFlag {
+    id: string;
+    key: string;
+    name: string;
+    description?: string;
+    status: FeatureFlagStatus;
+    enabled: boolean;
+    percentage?: number;
+    segments?: FeatureFlagSegment[];
+    createdAt: Date;
+    updatedAt: Date;
+    createdBy?: string;
+    environment?: string;
+    tags?: string[];
+}
+export interface WakaFeatureFlagRowProps {
+    /** Feature flag data */
+    flag: FeatureFlag;
+    /** Callback when toggling the flag */
+    onToggle?: (enabled: boolean) => void;
+    /** Callback when changing percentage */
+    onPercentageChange?: (percentage: number) => void;
+    /** Callback when editing the flag */
+    onEdit?: () => void;
+    /** Callback when deleting the flag */
+    onDelete?: () => void;
+    /** Callback when viewing history */
+    onViewHistory?: () => void;
+    /** Callback when duplicating the flag */
+    onDuplicate?: () => void;
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Compact mode */
+    compact?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaFeatureFlagRow({ flag, onToggle, onPercentageChange, onEdit, onDelete, onViewHistory, onDuplicate, readOnly, compact, className, }: WakaFeatureFlagRowProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultFeatureFlags: FeatureFlag[];

package/dist/components/waka-kubernetes-overview/index.d.ts

@@ -0,0 +1,98 @@
+export type NodeStatus = "Ready" | "NotReady" | "Unknown";
+export type PodPhase = "Running" | "Pending" | "Succeeded" | "Failed" | "Unknown";
+export type DeploymentStatus = "Available" | "Progressing" | "Degraded";
+export interface K8sNode {
+    name: string;
+    status: NodeStatus;
+    roles: string[];
+    version: string;
+    cpu: {
+        used: number;
+        total: number;
+    };
+    memory: {
+        used: number;
+        total: number;
+    };
+    pods: {
+        running: number;
+        total: number;
+    };
+    conditions?: Array<{
+        type: string;
+        status: boolean;
+        message?: string;
+    }>;
+}
+export interface K8sPod {
+    name: string;
+    namespace: string;
+    phase: PodPhase;
+    ready: string;
+    restarts: number;
+    age: string;
+    node?: string;
+    labels?: Record<string, string>;
+}
+export interface K8sDeployment {
+    name: string;
+    namespace: string;
+    replicas: {
+        ready: number;
+        desired: number;
+    };
+    status: DeploymentStatus;
+    age: string;
+    image?: string;
+}
+export interface K8sService {
+    name: string;
+    namespace: string;
+    type: "ClusterIP" | "NodePort" | "LoadBalancer" | "ExternalName";
+    clusterIP: string;
+    externalIP?: string;
+    ports: Array<{
+        port: number;
+        targetPort: number;
+        protocol: string;
+    }>;
+    age: string;
+}
+export interface K8sNamespace {
+    name: string;
+    status: "Active" | "Terminating";
+    age: string;
+    labels?: Record<string, string>;
+}
+export interface WakaKubernetesOverviewProps {
+    /** Cluster name */
+    clusterName?: string;
+    /** List of nodes */
+    nodes: K8sNode[];
+    /** List of pods */
+    pods: K8sPod[];
+    /** List of deployments */
+    deployments: K8sDeployment[];
+    /** List of services */
+    services: K8sService[];
+    /** List of namespaces */
+    namespaces: K8sNamespace[];
+    /** Selected namespace filter */
+    selectedNamespace?: string;
+    /** Callback when changing namespace */
+    onNamespaceChange?: (namespace: string) => void;
+    /** Callback when clicking on a resource */
+    onResourceClick?: (type: string, name: string, namespace?: string) => void;
+    /** Callback when refreshing */
+    onRefresh?: () => void;
+    /** Whether data is loading */
+    isLoading?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+export declare function WakaKubernetesOverview({ clusterName, nodes, pods, deployments, services, namespaces, selectedNamespace, onNamespaceChange, onResourceClick, onRefresh, isLoading, className, }: WakaKubernetesOverviewProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultK8sNodes: K8sNode[];
+export declare const defaultK8sPods: K8sPod[];
+export declare const defaultK8sDeployments: K8sDeployment[];
+export declare const defaultK8sServices: K8sService[];
+export declare const defaultK8sNamespaces: K8sNamespace[];