@nice2dev/ui-tools 1.0.10

package/dist/edge-computing.d.ts

@@ -0,0 +1,720 @@
+/**
+ * @file edge-computing.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-16.3 — Edge Computing
+ *
+ * Types for edge device management: deployment, monitoring, logs,
+ * configuration, local analytics, store & forward, cloud integration.
+ */
+/** Edge platform */
+export type EdgePlatform = 'azureIotEdge' | 'awsGreengrass' | 'gcpIotEdge' | 'kubeEdge' | 'k3s' | 'openHorizon' | 'edgeX' | 'balena' | 'custom';
+/** Module status */
+export type ModuleStatus = 'running' | 'stopped' | 'restarting' | 'failed' | 'backoff' | 'creating' | 'removing' | 'unhealthy' | 'unknown';
+/** Deployment status */
+export type DeploymentStatus = 'pending' | 'applying' | 'applied' | 'failed' | 'rollback' | 'partial';
+/** Edge runtime */
+export type EdgeRuntime = 'docker' | 'containerd' | 'cri-o' | 'moby' | 'podman' | 'native';
+/** Edge manager configuration */
+export interface EdgeManagerConfig {
+    /** Platform */
+    platform?: EdgePlatform;
+    /** Hub connection */
+    hub?: EdgeHubConnection;
+    /** Theme */
+    theme?: EdgeManagerTheme;
+    /** Locale */
+    locale?: string;
+    /** Features */
+    features?: EdgeManagerFeatures;
+    /** Deployment config */
+    deployment?: DeploymentConfig;
+    /** Monitoring config */
+    monitoring?: EdgeMonitoringConfig;
+    /** Logging config */
+    logging?: EdgeLoggingConfig;
+}
+/** Edge hub connection */
+export interface EdgeHubConnection {
+    type: EdgePlatform;
+    connectionString?: string;
+    endpoint?: string;
+    registry?: ContainerRegistry;
+    credentials?: EdgeCredentials;
+}
+/** Container registry */
+export interface ContainerRegistry {
+    server: string;
+    username?: string;
+    password?: string;
+    email?: string;
+}
+/** Edge credentials */
+export interface EdgeCredentials {
+    type: 'connectionString' | 'certificate' | 'sasToken' | 'managedIdentity';
+    value?: string;
+    certificatePath?: string;
+    privateKeyPath?: string;
+}
+/** Edge manager theme */
+export interface EdgeManagerTheme {
+    name?: string;
+    background?: string;
+    surface?: string;
+    primary?: string;
+    statusColors?: ModuleStatusColors;
+}
+/** Module status colors */
+export interface ModuleStatusColors {
+    running?: string;
+    stopped?: string;
+    restarting?: string;
+    failed?: string;
+    creating?: string;
+    unknown?: string;
+}
+/** Edge manager features */
+export interface EdgeManagerFeatures {
+    deployment?: boolean;
+    monitoring?: boolean;
+    logging?: boolean;
+    configuration?: boolean;
+    localAnalytics?: boolean;
+    storeAndForward?: boolean;
+    layeredDeployment?: boolean;
+    routes?: boolean;
+}
+/** Deployment config */
+export interface DeploymentConfig {
+    manifestFormat?: 'json' | 'yaml';
+    validation?: boolean;
+    dryRun?: boolean;
+    rollback?: RollbackConfig;
+    approval?: ApprovalConfig;
+}
+/** Rollback config */
+export interface RollbackConfig {
+    auto?: boolean;
+    keepPrevious?: number;
+    healthCheck?: boolean;
+    healthCheckTimeout?: number;
+}
+/** Approval config */
+export interface ApprovalConfig {
+    required?: boolean;
+    approvers?: string[];
+    timeout?: number;
+}
+/** Edge monitoring config */
+export interface EdgeMonitoringConfig {
+    metrics?: boolean;
+    resources?: boolean;
+    health?: boolean;
+    polling?: PollingConfig;
+}
+/** Polling config */
+export interface PollingConfig {
+    enabled: boolean;
+    interval: number;
+}
+/** Edge logging config */
+export interface EdgeLoggingConfig {
+    enabled?: boolean;
+    level?: LogLevel;
+    retention?: number;
+    streaming?: boolean;
+    storage?: LogStorageConfig;
+}
+/** Log level */
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+/** Log storage config */
+export interface LogStorageConfig {
+    type: 'local' | 'cloud' | 'both';
+    maxSize?: number;
+    compress?: boolean;
+    upload?: boolean;
+}
+/** Edge device */
+export interface EdgeDevice {
+    id: string;
+    name: string;
+    platform: EdgePlatform;
+    status: EdgeDeviceStatus;
+    runtime: EdgeRuntimeInfo;
+    modules: EdgeModule[];
+    deployment?: EdgeDeployment;
+    resources: ResourceMetrics;
+    connectivity: ConnectivityStatus;
+    metadata?: EdgeDeviceMetadata;
+}
+/** Edge device status */
+export interface EdgeDeviceStatus {
+    online: boolean;
+    edgeAgentStatus: ModuleStatus;
+    edgeHubStatus: ModuleStatus;
+    lastActivity?: Date;
+    lastDeployment?: Date;
+    health: EdgeHealthStatus;
+}
+/** Edge health status */
+export type EdgeHealthStatus = 'healthy' | 'warning' | 'unhealthy' | 'unknown';
+/** Edge runtime info */
+export interface EdgeRuntimeInfo {
+    type: EdgeRuntime;
+    version: string;
+    osType: string;
+    osVersion?: string;
+    architecture: string;
+    deviceId?: string;
+    hostname?: string;
+}
+/** Resource metrics */
+export interface ResourceMetrics {
+    cpu: CpuMetrics;
+    memory: MemoryMetrics;
+    disk: DiskMetrics;
+    network?: NetworkMetrics;
+    gpu?: GpuMetrics;
+}
+/** CPU metrics */
+export interface CpuMetrics {
+    usage: number;
+    cores: number;
+    frequency?: number;
+    temperature?: number;
+    processes?: number;
+}
+/** Memory metrics */
+export interface MemoryMetrics {
+    used: number;
+    total: number;
+    available: number;
+    percent: number;
+    swap?: SwapMetrics;
+}
+/** Swap metrics */
+export interface SwapMetrics {
+    used: number;
+    total: number;
+    percent: number;
+}
+/** Disk metrics */
+export interface DiskMetrics {
+    used: number;
+    total: number;
+    available: number;
+    percent: number;
+    readRate?: number;
+    writeRate?: number;
+    iops?: number;
+}
+/** Network metrics */
+export interface NetworkMetrics {
+    bytesReceived: number;
+    bytesSent: number;
+    packetsReceived?: number;
+    packetsSent?: number;
+    errors?: number;
+    dropped?: number;
+    interfaces?: NetworkInterface[];
+}
+/** Network interface */
+export interface NetworkInterface {
+    name: string;
+    ipAddress: string;
+    macAddress?: string;
+    speed?: number;
+    status: 'up' | 'down';
+}
+/** GPU metrics */
+export interface GpuMetrics {
+    count: number;
+    gpus: GpuInfo[];
+}
+/** GPU info */
+export interface GpuInfo {
+    id: string;
+    name: string;
+    usage: number;
+    memory: number;
+    memoryTotal: number;
+    temperature?: number;
+    power?: number;
+}
+/** Connectivity status */
+export interface ConnectivityStatus {
+    cloud: boolean;
+    lastCloudContact?: Date;
+    localNetwork: boolean;
+    upstreamDevices?: string[];
+    downstreamDevices?: string[];
+}
+/** Edge device metadata */
+export interface EdgeDeviceMetadata {
+    manufacturer?: string;
+    model?: string;
+    serialNumber?: string;
+    location?: string;
+    zone?: string;
+    tags?: Record<string, string>;
+    custom?: Record<string, unknown>;
+}
+/** Edge module */
+export interface EdgeModule {
+    name: string;
+    type: ModuleType;
+    status: ModuleStatus;
+    image: ModuleImage;
+    settings?: ModuleSettings;
+    resources?: ModuleResourceUsage;
+    runtime?: ModuleRuntimeStatus;
+    twin?: ModuleTwin;
+}
+/** Module type */
+export type ModuleType = 'system' | 'user' | 'marketplace';
+/** Module image */
+export interface ModuleImage {
+    repository: string;
+    tag: string;
+    digest?: string;
+    platform?: ImagePlatform;
+}
+/** Image platform */
+export interface ImagePlatform {
+    os: string;
+    architecture: string;
+    variant?: string;
+}
+/** Module settings */
+export interface ModuleSettings {
+    createOptions?: CreateOptions;
+    startupOrder?: number;
+    restartPolicy?: RestartPolicy;
+    env?: EnvironmentVariable[];
+    mounts?: VolumeMount[];
+    ports?: PortBinding[];
+    devices?: DeviceMapping[];
+}
+/** Create options */
+export interface CreateOptions {
+    hostname?: string;
+    user?: string;
+    privileged?: boolean;
+    networkMode?: string;
+    ipcMode?: string;
+    pidMode?: string;
+    labels?: Record<string, string>;
+    capabilities?: ContainerCapabilities;
+    resources?: ResourceConstraints;
+}
+/** Container capabilities */
+export interface ContainerCapabilities {
+    add?: string[];
+    drop?: string[];
+}
+/** Resource constraints */
+export interface ResourceConstraints {
+    cpuShares?: number;
+    cpuQuota?: number;
+    cpuPeriod?: number;
+    memory?: number;
+    memorySwap?: number;
+    memoryReservation?: number;
+    gpuIds?: string[];
+    gpuCount?: number;
+}
+/** Restart policy */
+export interface RestartPolicy {
+    type: 'always' | 'never' | 'on-failure' | 'on-unhealthy';
+    maxRetries?: number;
+    delaySeconds?: number;
+}
+/** Environment variable */
+export interface EnvironmentVariable {
+    name: string;
+    value: string;
+    secret?: boolean;
+}
+/** Volume mount */
+export interface VolumeMount {
+    source: string;
+    target: string;
+    type: 'bind' | 'volume' | 'tmpfs';
+    readOnly?: boolean;
+}
+/** Port binding */
+export interface PortBinding {
+    hostPort: number;
+    containerPort: number;
+    protocol: 'tcp' | 'udp';
+    hostIp?: string;
+}
+/** Device mapping */
+export interface DeviceMapping {
+    host: string;
+    container: string;
+    permissions?: string;
+}
+/** Module resource usage */
+export interface ModuleResourceUsage {
+    cpu: number;
+    memory: number;
+    networkRx: number;
+    networkTx: number;
+    diskRead?: number;
+    diskWrite?: number;
+}
+/** Module runtime status */
+export interface ModuleRuntimeStatus {
+    startTime?: Date;
+    finishTime?: Date;
+    exitCode?: number;
+    statusDescription?: string;
+    restartCount?: number;
+}
+/** Module twin */
+export interface ModuleTwin {
+    desired: Record<string, unknown>;
+    reported: Record<string, unknown>;
+    version?: number;
+    etag?: string;
+}
+/** Edge deployment */
+export interface EdgeDeployment {
+    id: string;
+    name?: string;
+    priority: number;
+    target: DeploymentTarget;
+    content: DeploymentContent;
+    status: DeploymentStatus;
+    metrics?: DeploymentMetrics;
+    history?: DeploymentHistory[];
+    metadata?: DeploymentMetadata;
+}
+/** Deployment target */
+export interface DeploymentTarget {
+    condition: string;
+    deviceIds?: string[];
+    tags?: Record<string, string>;
+}
+/** Deployment content */
+export interface DeploymentContent {
+    modulesContent: ModulesContent;
+    routes?: RouteDefinition[];
+    storeAndForward?: StoreAndForwardConfig;
+}
+/** Modules content */
+export interface ModulesContent {
+    $edgeAgent: EdgeAgentDesired;
+    $edgeHub: EdgeHubDesired;
+    [moduleName: string]: ModuleDesired | EdgeAgentDesired | EdgeHubDesired;
+}
+/** Edge agent desired properties */
+export interface EdgeAgentDesired {
+    schemaVersion: string;
+    runtime: RuntimeSettings;
+    systemModules: SystemModuleSettings;
+    modules: Record<string, ModuleSpecification>;
+}
+/** Runtime settings */
+export interface RuntimeSettings {
+    type: EdgeRuntime;
+    settings: RuntimeConfig;
+}
+/** Runtime config */
+export interface RuntimeConfig {
+    minDockerVersion?: string;
+    loggingOptions?: LoggingOptions;
+    registryCredentials?: Record<string, RegistryCredential>;
+}
+/** Logging options */
+export interface LoggingOptions {
+    'log-driver'?: string;
+    'log-opts'?: Record<string, string>;
+}
+/** Registry credential */
+export interface RegistryCredential {
+    address: string;
+    username: string;
+    password: string;
+}
+/** System module settings */
+export interface SystemModuleSettings {
+    edgeAgent: ModuleSpecification;
+    edgeHub: ModuleSpecification;
+}
+/** Module specification */
+export interface ModuleSpecification {
+    type: string;
+    status: 'running' | 'stopped';
+    restartPolicy: string;
+    imagePullPolicy?: 'on-create' | 'never';
+    startupOrder?: number;
+    settings: ModuleImageSettings;
+    env?: Record<string, EnvValue>;
+}
+/** Module image settings */
+export interface ModuleImageSettings {
+    image: string;
+    createOptions?: string | CreateOptions;
+}
+/** Environment value */
+export interface EnvValue {
+    value: string;
+}
+/** Edge hub desired properties */
+export interface EdgeHubDesired {
+    schemaVersion: string;
+    routes: Record<string, RouteConfig>;
+    storeAndForwardConfiguration: StoreForwardSettings;
+}
+/** Route config */
+export interface RouteConfig {
+    route: string;
+    priority?: number;
+    timeToLiveSecs?: number;
+}
+/** Store forward settings */
+export interface StoreForwardSettings {
+    timeToLiveSecs: number;
+}
+/** Module desired properties */
+export interface ModuleDesired {
+    properties?: {
+        desired?: Record<string, unknown>;
+    };
+}
+/** Route definition */
+export interface RouteDefinition {
+    name: string;
+    value: string;
+    source: RouteEndpoint;
+    sink: RouteEndpoint;
+    condition?: string;
+    priority?: number;
+    ttl?: number;
+}
+/** Route endpoint */
+export interface RouteEndpoint {
+    type: 'module' | 'upstream' | 'downstream';
+    name?: string;
+    output?: string;
+    input?: string;
+}
+/** Store and forward config */
+export interface StoreAndForwardConfig {
+    enabled: boolean;
+    timeToLiveSecs: number;
+    maxMessages?: number;
+    maxSizeMB?: number;
+    priorityQueues?: boolean;
+}
+/** Deployment metrics */
+export interface DeploymentMetrics {
+    targeted: number;
+    applied: number;
+    reported: number;
+    system: SystemMetrics;
+}
+/** System metrics */
+export interface SystemMetrics {
+    targetedCount: number;
+    appliedCount: number;
+    reportedSuccessfulCount: number;
+    reportedFailedCount: number;
+}
+/** Deployment history */
+export interface DeploymentHistory {
+    version: number;
+    timestamp: Date;
+    status: DeploymentStatus;
+    appliedBy?: string;
+    changes?: string;
+}
+/** Deployment metadata */
+export interface DeploymentMetadata {
+    created: Date;
+    createdBy?: string;
+    modified?: Date;
+    modifiedBy?: string;
+    version?: number;
+    labels?: Record<string, string>;
+}
+/** Edge log entry */
+export interface EdgeLogEntry {
+    timestamp: Date;
+    level: LogLevel;
+    module: string;
+    message: string;
+    container?: string;
+    stream?: 'stdout' | 'stderr';
+    properties?: Record<string, unknown>;
+}
+/** Log query */
+export interface EdgeLogQuery {
+    deviceId?: string;
+    modules?: string[];
+    level?: LogLevel;
+    startTime?: Date;
+    endTime?: Date;
+    search?: string;
+    regex?: boolean;
+    limit?: number;
+    tail?: number;
+    follow?: boolean;
+}
+/** Log query result */
+export interface EdgeLogResult {
+    logs: EdgeLogEntry[];
+    hasMore: boolean;
+    nextToken?: string;
+}
+/** Edge analytics rule */
+export interface EdgeAnalyticsRule {
+    id: string;
+    name: string;
+    enabled: boolean;
+    condition: AnalyticsCondition;
+    actions: AnalyticsAction[];
+    windowSize?: number;
+    throttle?: number;
+}
+/** Analytics condition */
+export interface AnalyticsCondition {
+    type: 'threshold' | 'change' | 'pattern' | 'anomaly' | 'expression';
+    metric?: string;
+    operator?: 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'neq';
+    value?: number;
+    expression?: string;
+    pattern?: string;
+}
+/** Analytics action */
+export interface AnalyticsAction {
+    type: 'message' | 'method' | 'alert' | 'log' | 'custom';
+    target?: string;
+    payload?: unknown;
+    method?: string;
+}
+/** Edge ML model */
+export interface EdgeMLModel {
+    id: string;
+    name: string;
+    version: string;
+    framework: MLFramework;
+    format: ModelFormat;
+    inputSchema?: ModelSchema;
+    outputSchema?: ModelSchema;
+    size?: number;
+    hardware?: HardwareRequirement;
+    metadata?: ModelMetadata;
+}
+/** ML framework */
+export type MLFramework = 'tensorflow' | 'tensorflowLite' | 'pytorch' | 'onnx' | 'opencv' | 'custom';
+/** Model format */
+export type ModelFormat = 'savedModel' | 'tflite' | 'torchScript' | 'onnx' | 'openvino' | 'custom';
+/** Model schema */
+export interface ModelSchema {
+    type: 'tensor' | 'image' | 'json';
+    shape?: number[];
+    dtype?: string;
+    format?: string;
+}
+/** Hardware requirement */
+export interface HardwareRequirement {
+    cpu?: boolean;
+    gpu?: boolean;
+    npu?: boolean;
+    minMemory?: number;
+    minStorage?: number;
+}
+/** Model metadata */
+export interface ModelMetadata {
+    author?: string;
+    description?: string;
+    created?: Date;
+    accuracy?: number;
+    latency?: number;
+    tags?: string[];
+}
+/** Azure IoT Edge specific */
+export interface AzureIoTEdgeConfig {
+    connectionString?: string;
+    deviceId?: string;
+    iotHubName?: string;
+    scopeId?: string;
+    provisioningHost?: string;
+    attestationType?: 'symmetricKey' | 'x509' | 'tpm';
+}
+/** AWS Greengrass specific */
+export interface AWSGreengrassConfig {
+    coreDevice?: CoreDeviceConfig;
+    componentConfig?: ComponentConfig;
+    credentials?: AWSCredentials;
+}
+/** Core device config */
+export interface CoreDeviceConfig {
+    thingName: string;
+    thingArn?: string;
+    status?: string;
+    lastStatusUpdate?: Date;
+}
+/** Component config */
+export interface ComponentConfig {
+    componentName: string;
+    componentVersion: string;
+    configurationUpdate?: Record<string, unknown>;
+}
+/** AWS credentials */
+export interface AWSCredentials {
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    sessionToken?: string;
+    region?: string;
+}
+/** GCP IoT Edge specific */
+export interface GCPIoTEdgeConfig {
+    projectId?: string;
+    region?: string;
+    registryId?: string;
+    deviceId?: string;
+    credentials?: GCPCredentials;
+}
+/** GCP credentials */
+export interface GCPCredentials {
+    type: 'serviceAccount' | 'applicationDefault';
+    keyFile?: string;
+    clientEmail?: string;
+}
+/** KubeEdge specific */
+export interface KubeEdgeConfig {
+    cloudCore?: CloudCoreConfig;
+    edgeCore?: EdgeCoreConfig;
+    deviceModel?: DeviceModelConfig;
+}
+/** Cloud core config */
+export interface CloudCoreConfig {
+    endpoint?: string;
+    namespace?: string;
+    token?: string;
+}
+/** Edge core config */
+export interface EdgeCoreConfig {
+    nodeName?: string;
+    mqttMode?: 'internal' | 'external';
+    edgedEndpoint?: string;
+}
+/** Device model config */
+export interface DeviceModelConfig {
+    name?: string;
+    namespace?: string;
+    protocol?: string;
+    properties?: DeviceProperty[];
+}
+/** Device property */
+export interface DeviceProperty {
+    name: string;
+    description?: string;
+    dataType: string;
+    accessMode: 'ReadOnly' | 'ReadWrite';
+    defaultValue?: unknown;
+}
+//# sourceMappingURL=edge-computing.d.ts.map