@wakastellar/ui 2.1.1 → 2.3.0

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/auth-2fa/index.d.ts

@@ -0,0 +1,38 @@
+export type TwoFactorMethod = "authenticator" | "sms" | "email" | "hardware";
+export interface BackupCode {
+    code: string;
+    used: boolean;
+}
+export interface TwoFactorStatus {
+    enabled: boolean;
+    method?: TwoFactorMethod;
+    phone?: string;
+    email?: string;
+    lastVerified?: Date | string;
+}
+export interface Auth2FAProps {
+    /** Current 2FA status */
+    status?: TwoFactorStatus;
+    /** Available methods */
+    availableMethods?: TwoFactorMethod[];
+    /** QR code data URL for authenticator setup */
+    qrCodeUrl?: string;
+    /** Secret key for manual entry */
+    secretKey?: string;
+    /** Backup codes */
+    backupCodes?: BackupCode[];
+    /** Handler for enabling 2FA */
+    onEnable?: (method: TwoFactorMethod, verificationCode: string) => Promise<boolean>;
+    /** Handler for disabling 2FA */
+    onDisable?: (verificationCode: string) => Promise<boolean>;
+    /** Handler for regenerating backup codes */
+    onRegenerateBackupCodes?: () => Promise<BackupCode[]>;
+    /** Handler for sending verification code */
+    onSendCode?: (method: TwoFactorMethod) => Promise<boolean>;
+    /** Custom className */
+    className?: string;
+}
+export declare function Auth2FA({ status, availableMethods, qrCodeUrl, secretKey, backupCodes, onEnable, onDisable, onRegenerateBackupCodes, onSendCode, className, }: Auth2FAProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultBackupCodes: BackupCode[];
+export declare const defaultStatus: TwoFactorStatus;
+export default Auth2FA;

package/dist/blocks/chat-interface/index.d.ts

@@ -0,0 +1,66 @@
+export interface ChatUser {
+    id: string;
+    name: string;
+    avatar?: string;
+    status?: "online" | "offline" | "away" | "busy";
+    lastSeen?: Date | string;
+}
+export interface ChatMessage {
+    id: string;
+    content: string;
+    senderId: string;
+    timestamp: Date | string;
+    status?: "sending" | "sent" | "delivered" | "read";
+    replyTo?: string;
+    attachments?: ChatAttachment[];
+    reactions?: ChatReaction[];
+}
+export interface ChatAttachment {
+    id: string;
+    type: "image" | "file" | "audio";
+    name: string;
+    url: string;
+    size?: string;
+    thumbnail?: string;
+}
+export interface ChatReaction {
+    emoji: string;
+    userId: string;
+}
+export interface ChatConversation {
+    id: string;
+    participants: ChatUser[];
+    lastMessage?: ChatMessage;
+    unreadCount?: number;
+    isPinned?: boolean;
+    isGroup?: boolean;
+    groupName?: string;
+    groupAvatar?: string;
+}
+export interface ChatInterfaceProps {
+    /** Current user */
+    currentUser: ChatUser;
+    /** List of conversations */
+    conversations?: ChatConversation[];
+    /** Currently selected conversation */
+    selectedConversation?: ChatConversation;
+    /** Messages in selected conversation */
+    messages?: ChatMessage[];
+    /** Handler for sending message */
+    onSendMessage?: (content: string, attachments?: File[]) => void;
+    /** Handler for selecting conversation */
+    onSelectConversation?: (conversation: ChatConversation) => void;
+    /** Handler for typing indicator */
+    onTyping?: () => void;
+    /** Users currently typing */
+    typingUsers?: ChatUser[];
+    /** Show sidebar */
+    showSidebar?: boolean;
+    /** Custom className */
+    className?: string;
+}
+export declare function ChatInterface({ currentUser, conversations, selectedConversation, messages, onSendMessage, onSelectConversation, onTyping, typingUsers, showSidebar, className, }: ChatInterfaceProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultUsers: ChatUser[];
+export declare const defaultConversations: ChatConversation[];
+export declare const defaultMessages: ChatMessage[];
+export default ChatInterface;

package/dist/blocks/checkout-flow/index.d.ts

@@ -0,0 +1,76 @@
+import * as React from "react";
+export interface CartItem {
+    id: string;
+    name: string;
+    description?: string;
+    price: number;
+    quantity: number;
+    image?: string;
+    variant?: string;
+}
+export interface ShippingMethod {
+    id: string;
+    name: string;
+    description: string;
+    price: number;
+    estimatedDays: string;
+    icon?: React.ReactNode;
+}
+export interface PaymentMethod {
+    id: string;
+    type: "card" | "paypal" | "apple" | "google" | "bank";
+    label: string;
+    icon?: React.ReactNode;
+    last4?: string;
+}
+export interface CheckoutAddress {
+    firstName: string;
+    lastName: string;
+    email: string;
+    phone: string;
+    address: string;
+    apartment?: string;
+    city: string;
+    state: string;
+    postalCode: string;
+    country: string;
+}
+export interface CheckoutFlowProps {
+    /** Cart items */
+    items: CartItem[];
+    /** Available shipping methods */
+    shippingMethods?: ShippingMethod[];
+    /** Available payment methods */
+    paymentMethods?: PaymentMethod[];
+    /** Coupon code handler */
+    onApplyCoupon?: (code: string) => Promise<{
+        discount: number;
+        type: "percent" | "fixed";
+    } | null>;
+    /** Applied discount */
+    discount?: {
+        code: string;
+        amount: number;
+        type: "percent" | "fixed";
+    };
+    /** Remove discount */
+    onRemoveDiscount?: () => void;
+    /** Submit order handler */
+    onSubmitOrder?: (data: {
+        address: CheckoutAddress;
+        shippingMethod: string;
+        paymentMethod: string;
+        saveInfo: boolean;
+    }) => Promise<void>;
+    /** Currency symbol */
+    currency?: string;
+    /** Tax rate (percentage) */
+    taxRate?: number;
+    /** Custom className */
+    className?: string;
+}
+export declare function CheckoutFlow({ items, shippingMethods, paymentMethods, onApplyCoupon, discount, onRemoveDiscount, onSubmitOrder, currency, taxRate, className, }: CheckoutFlowProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultShippingMethods: ShippingMethod[];
+export declare const defaultPaymentMethods: PaymentMethod[];
+export declare const defaultCartItems: CartItem[];
+export default CheckoutFlow;

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/dashboard-kpi/index.d.ts

@@ -0,0 +1,69 @@
+import * as React from "react";
+export interface KPIMetric {
+    id: string;
+    label: string;
+    value: string | number;
+    previousValue?: string | number;
+    change?: number;
+    changeLabel?: string;
+    trend?: "up" | "down" | "neutral";
+    icon?: React.ReactNode;
+    color?: "default" | "blue" | "green" | "yellow" | "red" | "purple";
+    sparkline?: number[];
+    target?: number;
+    current?: number;
+}
+export interface KPIChartData {
+    label: string;
+    value: number;
+    color?: string;
+}
+export interface DashboardKPIProps {
+    /** Title of the dashboard */
+    title?: string;
+    /** Description */
+    description?: string;
+    /** Main KPI metrics */
+    metrics: KPIMetric[];
+    /** Period selector options */
+    periods?: {
+        value: string;
+        label: string;
+    }[];
+    /** Selected period */
+    selectedPeriod?: string;
+    /** Period change handler */
+    onPeriodChange?: (period: string) => void;
+    /** Refresh handler */
+    onRefresh?: () => void;
+    /** Export handler */
+    onExport?: () => void;
+    /** Custom chart component */
+    chart?: React.ReactNode;
+    /** Secondary metrics for the bottom section */
+    secondaryMetrics?: KPIMetric[];
+    /** Goals/targets section */
+    goals?: {
+        id: string;
+        label: string;
+        current: number;
+        target: number;
+        unit?: string;
+    }[];
+    /** Loading state */
+    isLoading?: boolean;
+    /** Last updated timestamp */
+    lastUpdated?: string | Date;
+    /** Custom className */
+    className?: string;
+}
+export declare function DashboardKPI({ title, description, metrics, periods, selectedPeriod, onPeriodChange, onRefresh, onExport, chart, secondaryMetrics, goals, isLoading, lastUpdated, className, }: DashboardKPIProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultKPIMetrics: KPIMetric[];
+export declare const defaultGoals: {
+    id: string;
+    label: string;
+    current: number;
+    target: number;
+    unit: string;
+}[];
+export default DashboardKPI;

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/deployment-dashboard/index.d.ts

@@ -0,0 +1,68 @@
+export type DeploymentStatus = "pending" | "building" | "deploying" | "success" | "failed" | "cancelled" | "rollback";
+export type Environment = "development" | "staging" | "production";
+export interface Deployment {
+    id: string;
+    status: DeploymentStatus;
+    environment: Environment;
+    branch: string;
+    commit: string;
+    commitMessage: string;
+    author: {
+        name: string;
+        avatar?: string;
+    };
+    startedAt: Date | string;
+    finishedAt?: Date | string;
+    duration?: string;
+    url?: string;
+    logs?: string[];
+}
+export interface Pipeline {
+    id: string;
+    name: string;
+    status: DeploymentStatus;
+    stages: PipelineStage[];
+    trigger: string;
+    branch: string;
+    startedAt: Date | string;
+}
+export interface PipelineStage {
+    id: string;
+    name: string;
+    status: DeploymentStatus;
+    duration?: string;
+    logs?: string[];
+}
+export interface EnvironmentStatus {
+    name: Environment;
+    status: "healthy" | "degraded" | "down";
+    url: string;
+    lastDeployment?: Deployment;
+    uptime?: string;
+    responseTime?: string;
+}
+export interface DeploymentDashboardProps {
+    /** Recent deployments */
+    deployments?: Deployment[];
+    /** Active pipelines */
+    pipelines?: Pipeline[];
+    /** Environment statuses */
+    environments?: EnvironmentStatus[];
+    /** Handler for deploying */
+    onDeploy?: (environment: Environment, branch: string) => void;
+    /** Handler for rollback */
+    onRollback?: (deploymentId: string) => void;
+    /** Handler for cancelling */
+    onCancel?: (deploymentId: string) => void;
+    /** Handler for retrying */
+    onRetry?: (deploymentId: string) => void;
+    /** Available branches */
+    branches?: string[];
+    /** Custom className */
+    className?: string;
+}
+export declare function DeploymentDashboard({ deployments, pipelines, environments, onDeploy, onRollback, onCancel, onRetry, branches, className, }: DeploymentDashboardProps): import("react/jsx-runtime").JSX.Element;
+export declare const defaultDeployments: Deployment[];
+export declare const defaultPipelines: Pipeline[];
+export declare const defaultEnvironments: EnvironmentStatus[];
+export default DeploymentDashboard;

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[];