@wakastellar/ui 2.1.2 → 2.3.2

package/dist/blocks/apm-overview/index.d.ts

@@ -0,0 +1,58 @@
+export type ServiceStatus = "healthy" | "warning" | "critical" | "unknown";
+export type TimeRange = "1h" | "6h" | "24h" | "7d" | "30d";
+export interface ServiceMetrics {
+    requestsPerSecond: number;
+    avgResponseTime: number;
+    p50ResponseTime: number;
+    p95ResponseTime: number;
+    p99ResponseTime: number;
+    errorRate: number;
+    successRate: number;
+    activeConnections: number;
+    cpuUsage?: number;
+    memoryUsage?: number;
+    throughput?: number;
+}
+export interface ServiceEndpoint {
+    path: string;
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    requestsPerMinute: number;
+    avgResponseTime: number;
+    errorRate: number;
+    status: ServiceStatus;
+}
+export interface APMService {
+    id: string;
+    name: string;
+    type: "api" | "web" | "worker" | "database" | "cache" | "queue";
+    status: ServiceStatus;
+    metrics: ServiceMetrics;
+    previousMetrics?: ServiceMetrics;
+    endpoints?: ServiceEndpoint[];
+    instances?: number;
+    version?: string;
+    dependencies?: string[];
+    tags?: string[];
+}
+export interface APMTransaction {
+    id: string;
+    name: string;
+    service: string;
+    duration: number;
+    timestamp: Date;
+    status: "success" | "error";
+    traceId?: string;
+}
+export interface APMOverviewProps {
+    services: APMService[];
+    recentTransactions?: APMTransaction[];
+    timeRange?: TimeRange;
+    onTimeRangeChange?: (range: TimeRange) => void;
+    onServiceClick?: (service: APMService) => void;
+    onTransactionClick?: (transaction: APMTransaction) => void;
+    onRefresh?: () => void;
+    className?: string;
+}
+export declare function APMOverview({ services, recentTransactions, timeRange, onTimeRangeChange, onServiceClick, onTransactionClick, onRefresh, className, }: APMOverviewProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultAPMServices: APMService[];
+export declare const defaultAPMTransactions: APMTransaction[];

package/dist/blocks/cicd-builder/index.d.ts

@@ -0,0 +1,47 @@
+export type StepType = "build" | "test" | "deploy" | "script" | "docker" | "notify" | "approval" | "artifact" | "cache" | "parallel";
+export type StepStatus = "pending" | "running" | "success" | "failed" | "skipped" | "waiting";
+export interface PipelineStep {
+    id: string;
+    name: string;
+    type: StepType;
+    status?: StepStatus;
+    command?: string;
+    image?: string;
+    environment?: Record<string, string>;
+    artifacts?: string[];
+    dependsOn?: string[];
+    timeout?: number;
+    retries?: number;
+    condition?: string;
+    parallel?: PipelineStep[];
+}
+export interface PipelineStage {
+    id: string;
+    name: string;
+    steps: PipelineStep[];
+    status?: StepStatus;
+    runParallel?: boolean;
+}
+export interface Pipeline {
+    id: string;
+    name: string;
+    description?: string;
+    trigger?: {
+        branches?: string[];
+        events?: ("push" | "pull_request" | "tag" | "schedule")[];
+        schedule?: string;
+    };
+    stages: PipelineStage[];
+    variables?: Record<string, string>;
+}
+export interface CICDBuilderProps {
+    pipeline: Pipeline;
+    onPipelineChange?: (pipeline: Pipeline) => void;
+    onRun?: () => void;
+    onSave?: () => void;
+    onExport?: (format: "yaml" | "json") => void;
+    readOnly?: boolean;
+    className?: string;
+}
+export declare function CICDBuilder({ pipeline: initialPipeline, onPipelineChange, onRun, onSave, onExport, readOnly, className, }: CICDBuilderProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultPipeline: Pipeline;

package/dist/blocks/cloud-cost-dashboard/index.d.ts

@@ -0,0 +1,49 @@
+export type CloudProvider = "aws" | "gcp" | "azure" | "all";
+export type CostCategory = "compute" | "storage" | "database" | "network" | "security" | "other";
+export type TimeRange = "day" | "week" | "month" | "quarter" | "year";
+export interface CostItem {
+    id: string;
+    name: string;
+    category: CostCategory;
+    provider: CloudProvider;
+    cost: number;
+    previousCost?: number;
+    budget?: number;
+    usage?: number;
+    unit?: string;
+    trend?: number;
+    tags?: string[];
+}
+export interface CostSummary {
+    totalCost: number;
+    previousTotalCost?: number;
+    budget?: number;
+    forecast?: number;
+    byProvider: Record<CloudProvider, number>;
+    byCategory: Record<CostCategory, number>;
+    topServices: CostItem[];
+}
+export interface CostAnomaly {
+    id: string;
+    service: string;
+    expectedCost: number;
+    actualCost: number;
+    deviation: number;
+    timestamp: Date;
+    status: "new" | "acknowledged" | "resolved";
+}
+export interface CloudCostDashboardProps {
+    summary: CostSummary;
+    items: CostItem[];
+    anomalies?: CostAnomaly[];
+    timeRange?: TimeRange;
+    onTimeRangeChange?: (range: TimeRange) => void;
+    onProviderFilter?: (provider: CloudProvider) => void;
+    onExport?: () => void;
+    onRefresh?: () => void;
+    className?: string;
+}
+export declare function CloudCostDashboard({ summary, items, anomalies, timeRange, onTimeRangeChange, onProviderFilter, onExport, onRefresh, className, }: CloudCostDashboardProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultCloudCostSummary: CostSummary;
+export declare const defaultCloudCostItems: CostItem[];
+export declare const defaultCostAnomalies: CostAnomaly[];

package/dist/blocks/container-orchestrator/index.d.ts

@@ -0,0 +1,63 @@
+export type ContainerStatus = "running" | "stopped" | "paused" | "restarting" | "creating" | "removing" | "exited" | "dead";
+export type ServiceStatus = "running" | "updating" | "scaled" | "failed" | "pending";
+export interface ContainerResource {
+    cpu: number;
+    memory: number;
+    memoryLimit: number;
+    networkRx: number;
+    networkTx: number;
+}
+export interface OrchestratorContainer {
+    id: string;
+    name: string;
+    image: string;
+    status: ContainerStatus;
+    createdAt: Date;
+    startedAt?: Date;
+    ports?: {
+        host: number;
+        container: number;
+        protocol: "tcp" | "udp";
+    }[];
+    resources: ContainerResource;
+    healthCheck?: "healthy" | "unhealthy" | "starting" | "none";
+    restartCount?: number;
+    node?: string;
+}
+export interface OrchestratorService {
+    id: string;
+    name: string;
+    image: string;
+    status: ServiceStatus;
+    replicas: {
+        desired: number;
+        running: number;
+        ready: number;
+    };
+    containers: OrchestratorContainer[];
+    updateStatus?: {
+        state: "updating" | "completed" | "paused" | "rollback";
+        progress: number;
+        message?: string;
+    };
+    ports?: {
+        published: number;
+        target: number;
+    }[];
+    labels?: Record<string, string>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ContainerOrchestratorProps {
+    services: OrchestratorService[];
+    onScaleService?: (service: OrchestratorService, replicas: number) => void;
+    onRestartService?: (service: OrchestratorService) => void;
+    onStopService?: (service: OrchestratorService) => void;
+    onDeleteService?: (service: OrchestratorService) => void;
+    onViewLogs?: (container: OrchestratorContainer) => void;
+    onExecShell?: (container: OrchestratorContainer) => void;
+    onRefresh?: () => void;
+    className?: string;
+}
+export declare function ContainerOrchestrator({ services, onScaleService, onRestartService, onStopService, onDeleteService, onViewLogs, onExecShell, onRefresh, className, }: ContainerOrchestratorProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultOrchestratorServices: OrchestratorService[];

package/dist/blocks/database-admin/index.d.ts

@@ -0,0 +1,84 @@
+export type DatabaseStatus = "healthy" | "warning" | "critical" | "offline";
+export type BackupStatus = "completed" | "running" | "failed" | "scheduled";
+export type QueryStatus = "success" | "error" | "running";
+export interface DatabaseConnection {
+    id: string;
+    user: string;
+    database: string;
+    state: "active" | "idle" | "idle_in_transaction" | "waiting";
+    query?: string;
+    duration: number;
+    client: string;
+}
+export interface DatabaseBackup {
+    id: string;
+    name: string;
+    type: "full" | "incremental" | "point_in_time";
+    status: BackupStatus;
+    size?: number;
+    startedAt: Date;
+    completedAt?: Date;
+    duration?: number;
+}
+export interface SlowQuery {
+    id: string;
+    query: string;
+    calls: number;
+    totalTime: number;
+    meanTime: number;
+    maxTime: number;
+    rows: number;
+}
+export interface DatabaseMetrics {
+    connections: {
+        active: number;
+        idle: number;
+        max: number;
+    };
+    transactions: {
+        committed: number;
+        rolledBack: number;
+        perSecond: number;
+    };
+    cache: {
+        hitRatio: number;
+        bufferHit: number;
+        diskRead: number;
+    };
+    storage: {
+        used: number;
+        total: number;
+        tablespace: number;
+        indexes: number;
+    };
+    replication?: {
+        lag: number;
+        state: "streaming" | "catchup" | "disconnected";
+        replicas: number;
+    };
+}
+export interface DatabaseInstance {
+    id: string;
+    name: string;
+    type: "postgresql" | "mysql" | "mongodb" | "redis";
+    version: string;
+    host: string;
+    port: number;
+    status: DatabaseStatus;
+    role: "primary" | "replica" | "standalone";
+    metrics: DatabaseMetrics;
+    connections: DatabaseConnection[];
+    backups: DatabaseBackup[];
+    slowQueries: SlowQuery[];
+}
+export interface DatabaseAdminProps {
+    instance: DatabaseInstance;
+    onExecuteQuery?: (query: string) => void;
+    onCreateBackup?: () => void;
+    onRestoreBackup?: (backup: DatabaseBackup) => void;
+    onKillConnection?: (connection: DatabaseConnection) => void;
+    onRefresh?: () => void;
+    className?: string;
+}
+export declare function DatabaseAdmin({ instance, onExecuteQuery, onCreateBackup, onRestoreBackup, onKillConnection, onRefresh, className, }: DatabaseAdminProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultDatabaseInstance: DatabaseInstance;

package/dist/blocks/gitops-sync-status/index.d.ts

@@ -0,0 +1,45 @@
+export type SyncStatus = "synced" | "out_of_sync" | "syncing" | "failed" | "unknown" | "suspended";
+export type HealthStatus = "healthy" | "degraded" | "progressing" | "missing" | "unknown";
+export type ResourceKind = "Deployment" | "Service" | "ConfigMap" | "Secret" | "Ingress" | "PersistentVolumeClaim" | "CronJob" | "Job" | "StatefulSet" | "DaemonSet";
+export interface GitOpsResource {
+    kind: ResourceKind;
+    name: string;
+    namespace: string;
+    syncStatus: SyncStatus;
+    healthStatus: HealthStatus;
+    message?: string;
+    version?: string;
+}
+export interface GitOpsApplication {
+    id: string;
+    name: string;
+    project: string;
+    repo: {
+        url: string;
+        branch: string;
+        path: string;
+    };
+    destination: {
+        server: string;
+        namespace: string;
+    };
+    syncStatus: SyncStatus;
+    healthStatus: HealthStatus;
+    lastSyncedAt?: Date;
+    lastSyncedRevision?: string;
+    targetRevision?: string;
+    resources: GitOpsResource[];
+    message?: string;
+    autoSync?: boolean;
+}
+export interface GitOpsSyncStatusProps {
+    applications: GitOpsApplication[];
+    onSync?: (app: GitOpsApplication) => void;
+    onRefresh?: () => void;
+    onSuspend?: (app: GitOpsApplication) => void;
+    onResume?: (app: GitOpsApplication) => void;
+    onViewDetails?: (app: GitOpsApplication) => void;
+    className?: string;
+}
+export declare function GitOpsSyncStatus({ applications, onSync, onRefresh, onSuspend, onResume, onViewDetails, className, }: GitOpsSyncStatusProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultGitOpsApplications: GitOpsApplication[];

package/dist/blocks/incident-manager/index.d.ts

@@ -0,0 +1,44 @@
+export type IncidentSeverity = "critical" | "high" | "medium" | "low";
+export type IncidentStatus = "triggered" | "acknowledged" | "investigating" | "identified" | "resolved" | "closed";
+export interface IncidentResponder {
+    id: string;
+    name: string;
+    avatar?: string;
+    role: string;
+    status: "available" | "engaged" | "offline";
+}
+export interface IncidentEvent {
+    id: string;
+    type: "status_change" | "comment" | "assignment" | "escalation" | "runbook";
+    timestamp: Date;
+    user?: string;
+    content: string;
+}
+export interface Incident {
+    id: string;
+    title: string;
+    description?: string;
+    severity: IncidentSeverity;
+    status: IncidentStatus;
+    service?: string;
+    createdAt: Date;
+    acknowledgedAt?: Date;
+    resolvedAt?: Date;
+    responders: IncidentResponder[];
+    events: IncidentEvent[];
+    impact?: string;
+    affectedUsers?: number;
+    slackChannel?: string;
+    runbookUrl?: string;
+}
+export interface IncidentManagerProps {
+    incidents: Incident[];
+    onCreateIncident?: () => void;
+    onAcknowledge?: (incident: Incident) => void;
+    onResolve?: (incident: Incident) => void;
+    onEscalate?: (incident: Incident) => void;
+    onAssign?: (incident: Incident, responder: IncidentResponder) => void;
+    className?: string;
+}
+export declare function IncidentManager({ incidents, onCreateIncident, onAcknowledge, onResolve, onEscalate, onAssign, className, }: IncidentManagerProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultIncidents: Incident[];

package/dist/blocks/index.d.ts

@@ -37,3 +37,13 @@ export * from './auth-2fa';
 export { ChatInterface, defaultUsers as defaultChatInterfaceUsers, defaultConversations as defaultChatInterfaceConversations, defaultMessages as defaultChatInterfaceMessages, } from './chat-interface';
 export type { ChatInterfaceProps, ChatUser as ChatInterfaceUser, ChatMessage as ChatInterfaceMessage, ChatConversation as ChatInterfaceConversation, ChatAttachment as ChatInterfaceAttachment, ChatReaction as ChatInterfaceReaction, } from './chat-interface';
 export * from './deployment-dashboard';
+export { IncidentManager, defaultIncidents, type Incident, type IncidentSeverity, type IncidentStatus, type IncidentResponder, type IncidentEvent, type IncidentManagerProps, } from './incident-manager';
+export { InfrastructureMap, defaultInfraResources, type InfraResource, type ResourceType as InfraResourceType, type ResourceStatus as InfraResourceStatus, type CloudProvider as InfraCloudProvider, type InfrastructureMapProps, } from './infrastructure-map';
+export { CICDBuilder, defaultPipeline, type Pipeline as CICDPipeline, type PipelineStage as CICDPipelineStage, type PipelineStep, type StepType, type StepStatus, type CICDBuilderProps, } from './cicd-builder';
+export { ReleaseNotes, defaultReleases, type Release, type ReleaseType, type ReleaseStatus, type ChangeItem, type ChangeType, type Contributor, type ReleaseNotesProps, } from './release-notes';
+export { OnCallScheduleBlock, defaultOnCallSchedule, type OnCallSchedule, type OnCallShift, type OnCallUser, type RotationType, type EscalationLevel, type OnCallScheduleBlockProps, } from './on-call-schedule';
+export { CloudCostDashboard, defaultCloudCostSummary, defaultCloudCostItems, defaultCostAnomalies, type CostSummary, type CostItem, type CostAnomaly, type CostCategory, type CloudProvider as CostCloudProvider, type TimeRange as CostTimeRange, type CloudCostDashboardProps, } from './cloud-cost-dashboard';
+export { GitOpsSyncStatus, defaultGitOpsApplications, type GitOpsApplication, type GitOpsResource, type SyncStatus, type HealthStatus as GitOpsHealthStatus, type ResourceKind, type GitOpsSyncStatusProps, } from './gitops-sync-status';
+export { APMOverview, defaultAPMServices, defaultAPMTransactions, type APMService, type APMTransaction, type ServiceMetrics as APMServiceMetrics, type ServiceEndpoint as APMServiceEndpoint, type ServiceStatus as APMServiceStatus, type TimeRange as APMTimeRange, type APMOverviewProps, } from './apm-overview';
+export { ContainerOrchestrator, defaultOrchestratorServices, type OrchestratorService, type OrchestratorContainer, type ContainerStatus as OrchestratorContainerStatus, type ServiceStatus as OrchestratorServiceStatus, type ContainerResource, type ContainerOrchestratorProps, } from './container-orchestrator';
+export { DatabaseAdmin, defaultDatabaseInstance, type DatabaseInstance, type DatabaseConnection, type DatabaseBackup, type SlowQuery, type DatabaseMetrics as AdminDatabaseMetrics, type DatabaseStatus as AdminDatabaseStatus, type BackupStatus, type QueryStatus, type DatabaseAdminProps, } from './database-admin';

package/dist/blocks/infrastructure-map/index.d.ts

@@ -0,0 +1,32 @@
+export type ResourceType = "region" | "vpc" | "subnet" | "server" | "database" | "loadbalancer" | "cache" | "storage" | "container" | "function" | "cdn" | "firewall";
+export type ResourceStatus = "healthy" | "warning" | "critical" | "unknown" | "maintenance";
+export type CloudProvider = "aws" | "gcp" | "azure" | "custom";
+export interface InfraResource {
+    id: string;
+    name: string;
+    type: ResourceType;
+    status: ResourceStatus;
+    provider?: CloudProvider;
+    region?: string;
+    metadata?: Record<string, string | number>;
+    children?: InfraResource[];
+    connections?: string[];
+    metrics?: {
+        cpu?: number;
+        memory?: number;
+        network?: number;
+        requests?: number;
+        latency?: number;
+        errors?: number;
+    };
+}
+export interface InfrastructureMapProps {
+    resources: InfraResource[];
+    onResourceClick?: (resource: InfraResource) => void;
+    onRefresh?: () => void;
+    showConnections?: boolean;
+    viewMode?: "tree" | "grid" | "topology";
+    className?: string;
+}
+export declare function InfrastructureMap({ resources, onResourceClick, onRefresh, showConnections, viewMode: initialViewMode, className, }: InfrastructureMapProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultInfraResources: InfraResource[];

package/dist/blocks/on-call-schedule/index.d.ts

@@ -0,0 +1,43 @@
+export type RotationType = "daily" | "weekly" | "biweekly" | "monthly" | "custom";
+export type EscalationLevel = 1 | 2 | 3;
+export interface OnCallUser {
+    id: string;
+    name: string;
+    email: string;
+    phone?: string;
+    avatar?: string;
+    timezone?: string;
+    status?: "available" | "busy" | "dnd" | "offline";
+}
+export interface OnCallShift {
+    id: string;
+    user: OnCallUser;
+    startTime: Date;
+    endTime: Date;
+    level: EscalationLevel;
+    overrideReason?: string;
+}
+export interface OnCallSchedule {
+    id: string;
+    name: string;
+    description?: string;
+    team: string;
+    rotation: RotationType;
+    escalationPolicy: {
+        level1Timeout: number;
+        level2Timeout: number;
+        level3Timeout: number;
+    };
+    shifts: OnCallShift[];
+    users: OnCallUser[];
+}
+export interface OnCallScheduleBlockProps {
+    schedule: OnCallSchedule;
+    onEditSchedule?: () => void;
+    onAddOverride?: (date: Date) => void;
+    onSwapShift?: (shift: OnCallShift) => void;
+    onContactOnCall?: (user: OnCallUser) => void;
+    className?: string;
+}
+export declare function OnCallScheduleBlock({ schedule, onEditSchedule, onAddOverride, onSwapShift, onContactOnCall, className, }: OnCallScheduleBlockProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultOnCallSchedule: OnCallSchedule;

package/dist/blocks/release-notes/index.d.ts

@@ -0,0 +1,49 @@
+export type ChangeType = "feature" | "fix" | "improvement" | "breaking" | "security" | "performance" | "docs" | "deprecation";
+export type ReleaseType = "major" | "minor" | "patch" | "prerelease";
+export type ReleaseStatus = "draft" | "published" | "scheduled";
+export interface Contributor {
+    id: string;
+    name: string;
+    username: string;
+    avatar?: string;
+}
+export interface ChangeItem {
+    id: string;
+    type: ChangeType;
+    title: string;
+    description?: string;
+    pullRequest?: {
+        number: number;
+        url: string;
+    };
+    commits?: string[];
+    contributors?: Contributor[];
+    breaking?: boolean;
+}
+export interface Release {
+    id: string;
+    version: string;
+    name?: string;
+    releaseType: ReleaseType;
+    status: ReleaseStatus;
+    publishedAt?: Date;
+    scheduledAt?: Date;
+    createdAt: Date;
+    changes: ChangeItem[];
+    summary?: string;
+    upgradeNotes?: string;
+    contributors: Contributor[];
+    compareUrl?: string;
+    downloadUrl?: string;
+}
+export interface ReleaseNotesProps {
+    releases: Release[];
+    onCreateRelease?: () => void;
+    onEditRelease?: (release: Release) => void;
+    onPublishRelease?: (release: Release) => void;
+    onAddChange?: (releaseId: string, change: ChangeItem) => void;
+    showEditor?: boolean;
+    className?: string;
+}
+export declare function ReleaseNotes({ releases, onCreateRelease, onEditRelease, onPublishRelease, onAddChange, showEditor, className, }: ReleaseNotesProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultReleases: Release[];

package/dist/components/index.d.ts

@@ -196,3 +196,37 @@ export { WakaEmptyState, WakaEmptyStateSearch, WakaEmptyStateError, useEmptyStat
 export * from './waka-feature-announcement';
 export * from './waka-progress-onboarding';
 export { WakaTooltipTour, useTooltipTour, type WakaTooltipTourProps, type TourStep as TooltipTourStep, type TooltipPlacement, type UseTooltipTourOptions, type UseTooltipTourReturn, } from './waka-tooltip-tour';
+export { WakaLogViewer, defaultLogs, type LogEntry, type LogLevel as WakaLogLevel, type WakaLogViewerProps, } from './waka-log-viewer';
+export { WakaTraceViewer, defaultTraceSpans, type TraceSpan, type SpanStatus, type WakaTraceViewerProps, } from './waka-trace-viewer';
+export { WakaAlertPanel, defaultAlerts as defaultPanelAlerts, type Alert as WakaPanelAlert, type AlertSeverity as WakaPanelAlertSeverity, type AlertStatus as WakaPanelAlertStatus, type WakaAlertPanelProps, } from './waka-alert-panel';
+export { WakaContainerList, defaultContainers, type Container, type ContainerStatus as WakaContainerStatus, type ContainerResource, type WakaContainerListProps, } from './waka-container-list';
+export { WakaKubernetesOverview, defaultK8sNodes, defaultK8sPods, defaultK8sDeployments, defaultK8sServices, defaultK8sNamespaces, type K8sNode, type K8sPod, type K8sDeployment, type K8sService, type K8sNamespace, type NodeStatus as K8sNodeStatus, type PodPhase as K8sPodPhase, type DeploymentStatus as K8sDeploymentStatus, type WakaKubernetesOverviewProps, } from './waka-kubernetes-overview';
+export { WakaPodCard, defaultPodDetails, type PodDetails, type PodContainer, type PodEvent, type PodPhase, type ContainerState, type WakaPodCardProps, } from './waka-pod-card';
+export { WakaServiceGraph, defaultServices, defaultConnections, type ServiceNode, type ServiceConnection, type ServiceHealth, type ServiceType, type WakaServiceGraphProps, } from './waka-service-graph';
+export { WakaBuildMatrix, defaultBuildMatrixColumns, defaultBuildMatrixRows, type BuildMatrixRow, type BuildCell, type BuildStatus as WakaBuildStatus, type WakaBuildMatrixProps, } from './waka-build-matrix';
+export { WakaTestReport, defaultTestSuites, defaultCoverage, type TestSuite, type TestCase, type CoverageReport, type TestStatus, type WakaTestReportProps, } from './waka-test-report';
+export { WakaArtifactList, defaultArtifacts, type Artifact, type WakaArtifactListProps, } from './waka-artifact-list';
+export { WakaSecurityScanResult, defaultVulnerabilities, type Vulnerability, type VulnerabilitySeverity, type ScanType, type ScanSummary, type WakaSecurityScanResultProps, } from './waka-security-scan-result';
+export { WakaDependencyTree, defaultDependencies, type Dependency, type DependencyType, type VulnSeverity as DependencyVulnSeverity, type WakaDependencyTreeProps, } from './waka-dependency-tree';
+export { WakaEnvVarEditor, defaultEnvVariables, type EnvVariable, type WakaEnvVarEditorProps, } from './waka-env-var-editor';
+export { WakaSecretCard, defaultSecret, type Secret, type SecretAccess, type WakaSecretCardProps, } from './waka-secret-card';
+export { WakaConfigComparator, defaultConfigEnvironments, type ConfigEnvironment, type ConfigValue, type ConfigDiff, type DiffType, type WakaConfigComparatorProps, } from './waka-config-comparator';
+export { WakaFeatureFlagRow, defaultFeatureFlags, type FeatureFlag, type FeatureFlagStatus, type FeatureFlagSegment, type WakaFeatureFlagRowProps, } from './waka-feature-flag-row';
+export { WakaDatabaseCard, defaultDatabase, defaultDatabases, type DatabaseInfo, type DatabaseMetrics, type DatabaseType as WakaDatabaseType, type DatabaseStatus as WakaDatabaseStatus, type ReplicationRole, type WakaDatabaseCardProps, } from './waka-database-card';
+export { WakaMigrationList, defaultMigrations, type Migration, type MigrationStatus, type WakaMigrationListProps, } from './waka-migration-list';
+export { WakaQueryExplain, defaultQueryPlan, type QueryPlan, type ExplainNode, type NodeType, type WakaQueryExplainProps, } from './waka-query-explain';
+export { WakaAdProvider, useAdContext, useAdVisibility, useAdConsent, useAdSlot, AD_SIZES, type AdNetwork, type AdSize, type AdPosition, type AdSlot, type AdConfig, type AdEvent, type CustomAd, } from './waka-ad-provider';
+export { WakaAdBanner, type WakaAdBannerProps, } from './waka-ad-banner';
+export { WakaAdPlaceholder, type WakaAdPlaceholderProps, } from './waka-ad-placeholder';
+export { WakaAdFallback, type WakaAdFallbackProps, type AdFallbackVariant, } from './waka-ad-fallback';
+export { WakaSponsoredBadge, type WakaSponsoredBadgeProps, type SponsoredBadgeVariant, type SponsoredBadgeSize, } from './waka-sponsored-badge';
+export { WakaAdSidebar, type WakaAdSidebarProps, } from './waka-ad-sidebar';
+export { WakaAdInline, type WakaAdInlineProps, } from './waka-ad-inline';
+export { WakaAdInterstitial, type WakaAdInterstitialProps, } from './waka-ad-interstitial';
+export { WakaAdStickyFooter, type WakaAdStickyFooterProps, } from './waka-ad-sticky-footer';
+export { WakaSponsoredCard, type WakaSponsoredCardProps, type SponsoredCardVariant, } from './waka-sponsored-card';
+export { WakaSponsoredFeed, type WakaSponsoredFeedProps, } from './waka-sponsored-feed';
+export { WakaContentRecommendation, type WakaContentRecommendationProps, type RecommendationLayout, } from './waka-content-recommendation';
+export { WakaVideoAd, type WakaVideoAdProps, } from './waka-video-ad';
+export { WakaOutstreamVideo, type WakaOutstreamVideoProps, } from './waka-outstream-video';
+export { WakaVideoOverlay, type WakaVideoOverlayProps, type OverlayPosition, type OverlayTrigger, } from './waka-video-overlay';

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

@@ -0,0 +1,36 @@
+import { AdSize } from '../waka-ad-provider';
+import * as React from "react";
+export interface WakaAdBannerProps {
+    /** Unique slot ID */
+    slotId: string;
+    /** Ad size preset */
+    size?: AdSize;
+    /** Custom width (when size is "custom") */
+    customWidth?: number;
+    /** Custom height (when size is "custom") */
+    customHeight?: number;
+    /** GPT ad unit path (for GPT network) */
+    adUnitPath?: string;
+    /** Targeting parameters */
+    targeting?: Record<string, string | string[]>;
+    /** Auto-refresh interval in seconds (0 = disabled) */
+    refreshInterval?: number;
+    /** Enable lazy loading */
+    lazyLoad?: boolean;
+    /** Fallback content when no ad available */
+    fallback?: React.ReactNode;
+    /** Show sponsored badge */
+    showBadge?: boolean;
+    /** Badge position */
+    badgePosition?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+    /** Custom class name */
+    className?: string;
+    /** Callback when ad loads */
+    onLoad?: () => void;
+    /** Callback when ad fails */
+    onError?: (error: Error) => void;
+    /** Callback when ad is clicked */
+    onClick?: () => void;
+}
+export declare function WakaAdBanner({ slotId, size, customWidth, customHeight, adUnitPath, targeting, refreshInterval, lazyLoad, fallback, showBadge, badgePosition, className, onLoad, onError, onClick, }: WakaAdBannerProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdBanner;

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

@@ -0,0 +1,33 @@
+import { AdSize } from '../waka-ad-provider';
+import * as React from "react";
+export type AdFallbackVariant = "house" | "empty" | "custom";
+export interface WakaAdFallbackProps {
+    /** Fallback variant */
+    variant?: AdFallbackVariant;
+    /** Ad size preset */
+    size?: AdSize;
+    /** Width in pixels (overrides size) */
+    width?: number;
+    /** Height in pixels (overrides size) */
+    height?: number;
+    /** Title text */
+    title?: string;
+    /** Description text */
+    description?: string;
+    /** Call to action text */
+    ctaText?: string;
+    /** Link URL */
+    ctaUrl?: string;
+    /** Image URL */
+    imageUrl?: string;
+    /** Show border */
+    showBorder?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Callback when clicked */
+    onClick?: () => void;
+    /** Custom children for variant="custom" */
+    children?: React.ReactNode;
+}
+export declare function WakaAdFallback({ variant, size, width, height, title, description, ctaText, ctaUrl, imageUrl, showBorder, className, onClick, children, }: WakaAdFallbackProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdFallback;

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

@@ -0,0 +1,15 @@
+import { WakaAdBannerProps } from '../waka-ad-banner';
+export interface WakaAdInlineProps extends Omit<WakaAdBannerProps, "size"> {
+    /** Ad size - defaults to responsive */
+    size?: "responsive" | "rectangle" | "leaderboard";
+    /** Alignment within container */
+    align?: "left" | "center" | "right";
+    /** Vertical margin */
+    margin?: "none" | "sm" | "md" | "lg";
+    /** Show separator lines */
+    showSeparators?: boolean;
+    /** Label above the ad */
+    label?: string;
+}
+export declare function WakaAdInline({ slotId, size, align, margin, showSeparators, label, className, ...bannerProps }: WakaAdInlineProps): import("react/jsx-runtime").JSX.Element;
+export default WakaAdInline;