export declare enum OrgStatus {
    ACTIVE = "active",
    SUSPENDED = "suspended",
    TRIAL = "trial"
}
export declare enum ProjectStatus {
    PLANNING = "planning",
    ACTIVE = "active",
    PAUSED = "paused",
    COMPLETED = "completed",
    ARCHIVED = "archived"
}
export declare enum DeviceStatus {
    OFFLINE = "offline",
    ONLINE = "online",
    CAPTURING = "capturing",
    UPLOADING = "uploading",
    DEGRADED = "degraded",
    UPDATING = "updating",
    ERROR = "error"
}
export declare enum DeviceCommandType {
    CAPTURE_NOW = "capture_now",
    REBOOT = "reboot",
    SYNC_CONFIG = "sync_config",
    UPDATE_FIRMWARE = "update_firmware",
    TRIGGER_UPLOAD = "trigger_upload"
}
export declare enum CaptureStatus {
    PENDING = "pending",
    UPLOADED = "uploaded",
    PROCESSING = "processing",
    READY = "ready",
    FAILED = "failed"
}
export declare enum VideoStatus {
    PENDING = "pending",
    PROCESSING = "processing",
    READY = "ready",
    FAILED = "failed"
}
export declare enum AlertSeverity {
    INFO = "info",
    WARNING = "warning",
    ERROR = "error",
    CRITICAL = "critical"
}
export declare enum AlertType {
    DEVICE_OFFLINE = "device_offline",
    DEVICE_ERROR = "device_error",
    STORAGE_FULL = "storage_full",
    UPLOAD_FAILED = "upload_failed",
    CAPTURE_MISSED = "capture_missed",
    VIDEO_FAILED = "video_failed",
    FIRMWARE_UPDATE_AVAILABLE = "firmware_update_available"
}
export declare enum UserRole {
    SUPER_ADMIN = "super_admin",
    ORG_ADMIN = "org_admin",
    PROJECT_MANAGER = "project_manager",
    VIEWER = "viewer"
}
export declare enum CommandResultStatus {
    PENDING = "pending",
    DELIVERED = "delivered",
    ACKNOWLEDGED = "acknowledged",
    SUCCESS = "success",
    FAILED = "failed",
    TIMEOUT = "timeout"
}
export interface Organization {
    id: string;
    name: string;
    status: OrgStatus;
    planTier: string;
    createdAt: Date;
    updatedAt: Date;
}
export interface User {
    id: string;
    email: string;
    name: string;
    avatarUrl: string | null;
    provider: 'google' | 'email' | 'api_key';
    emailVerified: boolean;
    createdAt: Date;
    updatedAt: Date;
}
export interface Membership {
    userId: string;
    orgId: string;
    role: UserRole;
    invitedBy: string | null;
    joinedAt: Date;
}
export interface OrgMember extends User {
    role: UserRole;
    joinedAt: Date;
}
export interface AuthTokens {
    accessToken: string;
    refreshToken: string;
    expiresIn: number;
}
export interface AuthProvider {
    google?: {
        accessToken: string;
        refreshToken: string;
        expiresAt: number;
    };
}
export interface Project {
    id: string;
    orgId: string;
    name: string;
    description: string | null;
    timezone: string;
    startDate: Date | null;
    endDate: Date | null;
    status: ProjectStatus;
    captureInterval: number;
    resolution: string;
    createdAt: Date;
    updatedAt: Date;
}
export interface ProjectCreateInput {
    name: string;
    description?: string;
    timezone?: string;
    startDate?: string;
    endDate?: string;
    captureInterval?: number;
    resolution?: string;
}
export interface ProjectUpdateInput extends Partial<ProjectCreateInput> {
    status?: ProjectStatus;
}
export interface Device {
    id: string;
    projectId: string;
    orgId: string;
    serialNo: string;
    name: string;
    firmwareVersion: string | null;
    lastSeenAt: Date | null;
    status: DeviceStatus;
    config: DeviceConfig;
    createdAt: Date;
    updatedAt: Date;
}
export interface DeviceConfig {
    captureIntervalMinutes: number;
    resolution: string;
    quality: number;
    uploadOnWifiOnly: boolean;
    nightModeEnabled: boolean;
    nightModeStart: string;
    nightModeEnd: string;
    maxStorageGb: number;
    heartbeatIntervalSeconds: number;
    timezone: string;
}
export interface DeviceRegistrationInput {
    claimCode: string;
    serialNo: string;
    name: string;
    projectId: string;
}
export interface DeviceHeartbeatInput {
    deviceId: string;
    apiKey: string;
    status: DeviceStatus;
    tempC: number | null;
    batteryPct: number | null;
    storageFreeGb: number;
    capturesToday: number;
    lastCaptureAt: string | null;
    firmwareVersion: string;
    networkStatus: 'online' | 'offline' | 'degraded';
}
export interface DeviceCommandInput {
    deviceId: string;
    commandType: DeviceCommandType;
    payload?: Record<string, unknown>;
    scheduledAt?: string;
}
export interface Capture {
    id: string;
    projectId: string;
    deviceId: string;
    capturedAt: Date;
    uploadedAt: Date | null;
    fileKey: string | null;
    thumbnailKey: string | null;
    checksum: string | null;
    resolution: string;
    fileSizeBytes: number | null;
    exposureMs: number | null;
    iso: number | null;
    aperture: string | null;
    gpsLat: number | null;
    gpsLng: number | null;
    status: CaptureStatus;
    metadata: Record<string, unknown>;
    createdAt: Date;
}
export interface CaptureUploadInitResponse {
    captureId: string;
    uploadUrl: string;
    uploadMethod: 'PUT';
    uploadHeaders: Record<string, string>;
    expiresAt: string;
}
export interface CaptureCompleteInput {
    captureId: string;
    checksum: string;
    fileSizeBytes: number;
    metadata?: {
        exposureMs?: number;
        iso?: number;
        aperture?: string;
        gpsLat?: number;
        gpsLng?: number;
    };
}
export interface Video {
    id: string;
    projectId: string;
    periodStart: Date;
    periodEnd: Date;
    fps: number;
    resolution: string;
    fileKey: string | null;
    thumbnailKey: string | null;
    durationSec: number | null;
    status: VideoStatus;
    generatedAt: Date | null;
    fileSizeBytes: number | null;
    createdAt: Date;
}
export interface VideoGenerateInput {
    projectId: string;
    periodStart: string;
    periodEnd: string;
    fps?: number;
    resolution?: string;
}
export interface Alert {
    id: string;
    orgId: string;
    projectId: string | null;
    deviceId: string | null;
    type: AlertType;
    severity: AlertSeverity;
    message: string;
    data: Record<string, unknown>;
    state: 'open' | 'acknowledged' | 'resolved';
    openedAt: Date;
    acknowledgedAt: Date | null;
    acknowledgedBy: string | null;
    resolvedAt: Date | null;
}
export interface AlertRule {
    id: string;
    orgId: string;
    name: string;
    type: AlertType;
    condition: AlertCondition;
    cooldownMinutes: number;
    enabled: boolean;
    notifyEmail: boolean;
    notifySms: boolean;
    webhookUrl: string | null;
}
export interface AlertCondition {
    metric: string;
    operator: 'gt' | 'lt' | 'eq' | 'gte' | 'lte';
    value: number;
    windowMinutes?: number;
}
export interface Command {
    id: string;
    deviceId: string;
    commandType: DeviceCommandType;
    payload: Record<string, unknown> | null;
    queuedAt: Date;
    deliveredAt: Date | null;
    acknowledgedAt: Date | null;
    resultStatus: CommandResultStatus;
    resultData: Record<string, unknown> | null;
}
export interface ProjectAnalytics {
    projectId: string;
    totalCaptures: number;
    totalStorageBytes: number;
    avgCapturesPerDay: number;
    captureSuccessRate: number;
    uploadSuccessRate: number;
    activeDevices: number;
    offlineDevices: number;
    alertsOpen: number;
    periodStart: string;
    periodEnd: string;
}
export interface DeviceAnalytics {
    deviceId: string;
    totalCaptures: number;
    capturesToday: number;
    capturesThisWeek: number;
    avgUptimePercent: number;
    lastSeenAt: string | null;
    storageUsedGb: number;
    uploadQueueDepth: number;
}
export type WebSocketEvent = {
    event: 'device.status.changed';
    data: {
        deviceId: string;
        status: DeviceStatus;
        previousStatus: DeviceStatus;
    };
} | {
    event: 'device.heartbeat';
    data: {
        deviceId: string;
        status: DeviceStatus;
        storageFreeGb: number;
    };
} | {
    event: 'capture.upload.completed';
    data: {
        captureId: string;
        projectId: string;
        deviceId: string;
    };
} | {
    event: 'video.generation.completed';
    data: {
        videoId: string;
        projectId: string;
        status: VideoStatus;
    };
} | {
    event: 'alert.opened';
    data: {
        alertId: string;
        type: AlertType;
        severity: AlertSeverity;
    };
} | {
    event: 'alert.resolved';
    data: {
        alertId: string;
    };
};
export interface PaginationInput {
    page?: number;
    limit?: number;
    cursor?: string;
}
export interface PaginatedResult<T> {
    data: T[];
    total: number;
    page: number;
    limit: number;
    hasNextPage: boolean;
    nextCursor: string | null;
}
export interface ApiResponse<T> {
    success: boolean;
    data?: T;
    error?: {
        code: string;
        message: string;
        details?: Record<string, unknown>;
    };
}
//# sourceMappingURL=index.d.ts.map