/**
 * Make specific properties required in a type
 */
export type RequireFields<T, K extends keyof T> = T & Required<Pick<T, K>>;
/**
 * Make specific properties optional in a type
 */
export type OptionalFields<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
/**
 * Extract enum values as a union type
 */
export type EnumValues<T> = T[keyof T];
/**
 * Timestamp in milliseconds (Unix timestamp)
 */
export type Timestamp = number;
/**
 * ISO 8601 date string
 */
export type ISODateString = string;
/**
 * UUID string format
 */
export type UUID = string;
/**
 * Base entity interface with common fields
 */
export interface BaseEntity {
    id: UUID;
    created_at?: ISODateString;
    updated_at?: ISODateString;
}
/**
 * Status types for various entities
 */
export declare enum EntityStatus {
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE",
    AVAILABLE = "AVAILABLE",
    OCCUPIED = "OCCUPIED",
    BLOCKED = "BLOCKED",
    UNBLOCKED = "UNBLOCKED"
}
export declare enum TerminalType {
    ArmBarrier = "ARM_BARRIER",
    ElectricGate = "ELECTRIC_GATE",
    RisingBollard = "RISING_BOLLARD",
    GarageGate = "GARAGE_GATE"
}
export interface ClientConfig {
    apiKey?: string;
    baseUrl?: string;
    timeout?: number;
    email?: string;
    password?: string;
    environment?: Environment;
    logLevel?: LogLevel;
    silentLogs?: boolean;
    useHttps?: boolean;
    acceptSelfSigned?: boolean;
    rateLimitRetryCount?: number;
    rateLimitRetryDelay?: number;
}
export declare enum Environment {
    PRODUCTION = "production",
    STAGING = "staging",
    DEVELOPMENT = "development"
}
export declare enum LogLevel {
    ERROR = "error",
    WARN = "warn",
    INFO = "info",
    DEBUG = "debug"
}
export interface ApiResponse<T> {
    data: T;
    success: boolean;
    status: number;
    headers: Record<string, string>;
    total?: number;
    page?: number;
    limit?: number;
    pages?: number;
    hasNextPage?: boolean;
    hasPrevPage?: boolean;
}
export interface ErrorResponse {
    message: string;
    code: string;
    status: number;
}
export interface PaginationParams {
    page?: number;
    limit?: number;
    sort?: string;
    order?: 'asc' | 'desc';
}
export interface Pagination {
    total: number;
    page: number;
    limit: number;
    hasNextPage?: boolean;
    hasPrevPage?: boolean;
}
export interface PaginatedResponse<T> {
    data: T[];
    pagination: Pagination;
}
/**
 * Base filter interface that includes pagination
 */
export interface BaseFilters extends PaginationParams {
    search?: string;
}
export interface AuthCredentials {
    apiKey: string;
}
export interface AuthToken {
    token: string;
    expiresAt: Timestamp;
}
export interface TokenResponse {
    token: string;
    user: User;
    expiresIn?: number;
}
export interface Location {
    lat: number;
    lng: number;
}
export declare enum OperationalStatus {
    OFFLINE = "OFFLINE",
    ALARM = "ALARM",
    GUARDING = "GUARDING",
    ONGOING_PARKING = "ONGOING_PARKING",
    READY_TO_PARK = "READY_TO_PARK"
}
export interface Device extends BaseEntity {
    nick_name: string;
    serial_no: string;
    imei_number?: string;
    mac_address?: string;
    blocked?: boolean;
    sensor?: boolean;
    type: string;
    photo?: string;
    status: EntityStatus;
    description?: string;
    notes?: string;
    geo_lat?: number;
    geo_lng?: number;
    location?: string;
    gsm_signal?: number;
    ble_signal?: number;
    ble_password?: string;
    alarm_status?: number;
    battery_voltage?: number;
    terminal_type?: string;
    last_connection_date?: Date;
    is_public?: boolean;
    tenant_id?: UUID;
    qr_data?: string;
    device_code?: string;
    operational_status?: OperationalStatus;
}
export interface UserDevice extends Device {
    relationship_type: string;
    is_favorite: boolean;
    reservations: Reservation[];
}
export interface Reservation {
    userId?: string;
    device_id?: string;
    sharedDate?: string;
    reservationStatus: 'ACTIVE' | 'INACTIVE' | 'PENDING';
    startDate: string;
    endDate?: string;
}
export interface DeviceWithDistance extends Device {
    distance: number;
}
export interface DeviceLocationSearchResponse {
    success: boolean;
    data: Device[];
    total: number;
    page: number;
    limit: number;
}
export interface CreateDeviceRequest {
    serial_no: string;
    nick_name?: string;
    type?: string;
    terminal_armon_id?: string;
    firmware_version?: string;
    photo?: string;
    imei_number?: string;
    battery_voltage?: number;
    status?: string;
    sensor?: boolean;
    mac_address?: string;
    alarm_status?: string;
    ble_password?: string;
    auto_block_delay_duration?: string;
    alarm_duration?: string;
    geo_lat?: number;
    geo_lng?: number;
    location?: string;
    description?: string;
    notes?: string;
    auto_lock_status?: boolean;
    is_public?: boolean;
    tenant_id?: string;
}
export interface UpdateDeviceRequest {
    nick_name?: string;
    type?: string;
    terminal_type?: TerminalType;
    terminal_armon_id?: string;
    firmware_version?: string;
    photo?: string;
    imei_number?: string;
    battery_voltage?: number;
    status?: string;
    sensor?: boolean;
    mac_address?: string;
    alarm_status?: string;
    ble_password?: string;
    auto_block_delay_duration?: string;
    alarm_duration?: string;
    geo_lat?: number;
    geo_lng?: number;
    location?: string;
    description?: string;
    notes?: string;
    auto_lock_status?: boolean;
    is_public?: boolean;
    max_parking_time?: number;
    currency?: string;
    tenant_id?: string;
}
export type DeviceUpdateParams = UpdateDeviceRequest;
export interface AssignDeviceRequest {
    user_id: UUID;
    relationship_type?: string;
    permissions?: string[];
}
export interface UserDevice {
    id: UUID;
    name: string;
    surname: string;
    email: string;
    phone_number: string;
    relationship_type: string;
    is_favorite: boolean;
    access_granted_at: ISODateString;
}
export interface DeviceFilters extends BaseFilters {
    status?: EntityStatus | EntityStatus[];
    type?: string | string[];
    is_public?: boolean;
    tenant_id?: UUID;
    operational_status?: OperationalStatus;
}
export interface NearbyDevicesParams extends PaginationParams {
    lat: number;
    lng: number;
    radius?: number;
}
export interface DeviceTenantAssignParams {
    tenant_id: UUID;
}
export interface DeviceParkingAreaAssignParams {
    parking_area_id: UUID;
    association_type?: string;
    is_entry?: boolean;
    is_exit?: boolean;
}
export interface DeviceParkingAreaAssociation {
    success: boolean;
    data: {
        device: Device;
        parkingArea: ParkingArea;
        association: {
            parking_area_id: UUID;
            device_id: UUID;
            association_type?: string;
            is_entry?: boolean;
            is_exit?: boolean;
        };
    };
}
export interface QrDataInfo extends BaseEntity {
    data: string;
    device_code?: string;
    device_id?: UUID;
    is_assigned: boolean;
    device?: {
        id: UUID;
        nick_name?: string;
        serial_no?: string;
        type?: string;
        status?: EntityStatus;
    };
}
export interface QrDataCreateParams {
    qr_data: string;
    device_code?: string;
}
export interface QrDataBulkCreateParams {
    qr_codes: QrDataCreateParams[];
}
export interface QrDataAssignParams {
    qr_data?: string;
    device_code?: string;
    device_id: UUID;
}
export interface QrDataBulkAssignParams {
    assignments: QrDataAssignParams[];
}
export interface QrDataValidationResult {
    qr_data_exists: boolean;
    device_code_exists: boolean;
    qr_data_assigned: boolean;
    device_code_assigned: boolean;
}
export interface DeviceQrSummary {
    total_devices: number;
    devices_with_qr: number;
    devices_without_qr: number;
    total_qr_codes: number;
    assigned_qr_codes: number;
    unassigned_qr_codes: number;
}
export interface QrDataFilters extends BaseFilters {
    is_assigned?: boolean;
    device_id?: UUID;
    search?: string;
}
export interface Membership extends BaseEntity {
    name: string;
    description?: string;
    price: number;
    currency: string;
    period: number;
    period_unit: string;
    is_public: boolean;
    status: EntityStatus;
    tenant_id?: UUID;
}
export interface MembershipCreateParams {
    name: string;
    device_ids: UUID[];
    description?: string;
    price: number;
    currency: string;
    period: number;
    period_unit: string;
    public: boolean;
}
export interface MembershipUpdateParams {
    name?: string;
    device_ids?: UUID[];
    description?: string;
    price?: number;
    currency?: string;
    period?: number;
    period_unit?: string;
    public?: boolean;
}
export interface MembershipSubscription extends BaseEntity {
    user_id: UUID;
    membership_id: UUID;
    subscription_start: ISODateString;
    subscription_end: ISODateString;
    status: 'ACTIVE' | 'EXPIRED' | 'CANCELLED';
    membership?: Membership;
}
export interface MembershipFilters extends BaseFilters {
    status?: EntityStatus;
    name?: string;
}
export interface MembershipDevice {
    membership_id: UUID;
    device_id: UUID;
}
export interface Webhook extends BaseEntity {
    url: string;
    events: string[];
    is_active?: boolean;
}
export interface WebhookCreateParams {
    url: string;
    events: string[];
    is_active?: boolean;
}
export interface WebhookUpdateParams {
    url?: string;
    events?: string[];
    is_active?: boolean;
}
export interface RateLimitInfo {
    limit: number;
    remaining: number;
    reset: Timestamp;
}
export declare enum ParkingStatus {
    RESERVED = "RESERVED",
    ACTIVE = "ACTIVE",
    COMPLETED = "COMPLETED",
    PAID = "PAID",
    CANCELLED = "CANCELLED",
    ENDED = "ENDED",
    ARCHIVED = "ARCHIVED"
}
export interface Parking extends BaseEntity {
    reservation_date?: Timestamp;
    start?: Timestamp;
    end?: Timestamp;
    expected_end?: Timestamp;
    external_parking_id?: string;
    external_user_id?: string;
    status: ParkingStatus;
    device_id: UUID;
    user_id?: UUID;
    tenant_id?: UUID;
}
export interface ParkingCreateParams {
    reservation_date?: Timestamp;
    start?: Timestamp;
    expected_end?: Timestamp;
    external_parking_id?: string;
    external_user_id?: string;
    device_id: UUID;
    user_id?: UUID;
    status?: ParkingStatus;
}
export interface ParkingUpdateParams {
    reservation_date?: Timestamp;
    start?: Timestamp;
    end?: Timestamp;
    expected_end?: Timestamp;
    external_parking_id?: string;
    external_user_id?: string;
    status?: ParkingStatus;
    device_id?: UUID;
    user_id?: UUID;
}
export interface ParkingFilters extends BaseFilters {
    status?: ParkingStatus | ParkingStatus[];
    device_id?: UUID;
    user_id?: UUID;
    tenant_id?: UUID;
    external_parking_id?: string;
    external_user_id?: string;
    startFrom?: Timestamp;
    startTo?: Timestamp;
    endFrom?: Timestamp;
    endTo?: Timestamp;
    createdFrom?: Timestamp;
    createdTo?: Timestamp;
}
export declare enum ParkingAreaType {
    AREA = "AREA",
    GROUP = "GROUP",
    SINGLE = "SINGLE"
}
export type ParkingAreaDeviceAssignment = 'GENERAL' | 'ENTRY' | 'EXIT' | 'ENTRY_EXIT' | 'SENSOR';
export interface ParkingArea {
    id: string;
    name: string;
    total_spots?: number;
    available_spots?: number;
    type: ParkingAreaType;
    user_id: string;
    is_public?: boolean;
    currency?: string;
    hourly_rate?: number;
    first_hour_rate?: number;
    max_daily_rate?: number;
    free_minutes?: number;
    created_at?: Date;
    updated_at?: Date;
    devices?: ParkingAreaDevice[];
}
export interface ParkingAreaDevice {
    parking_area_id: string;
    device_id: string;
    association_type?: string;
    is_entry?: boolean;
    is_exit?: boolean;
    created_at?: Date;
    updated_at?: Date;
    assignment?: ParkingAreaDeviceAssignment;
    device?: Pick<Device, 'id' | 'serial_no' | 'nick_name' | 'type' | 'status' | 'blocked' | 'sensor' | 'location' | 'geo_lat' | 'geo_lng' | 'operational_status' | 'last_connection_date'>;
}
export interface CreateParkingArea {
    name: string;
    total_spots: number;
    available_spots: number;
    type: ParkingAreaType;
    is_public?: boolean;
    currency?: string;
    hourly_rate?: number;
    first_hour_rate?: number;
    max_daily_rate?: number;
    free_minutes?: number;
    devices?: CreateParkingAreaDevice[];
}
export interface CreateParkingAreaDevice {
    device_id: string;
    association_type?: string;
    is_entry?: boolean;
    is_exit?: boolean;
}
export interface ParkingAreaCreateParams {
    name: string;
    type: ParkingAreaType;
    total_spots?: number;
    is_public?: boolean;
    currency?: string;
    hourly_rate?: number;
    first_hour_rate?: number;
    max_daily_rate?: number;
    free_minutes?: number;
    devices?: CreateParkingAreaDevice[];
}
export interface ParkingAreaUpdateParams {
    name?: string;
    type?: ParkingAreaType;
    total_spots?: number;
    available_spots?: number;
    is_public?: boolean;
    currency?: string;
    hourly_rate?: number;
    first_hour_rate?: number;
    max_daily_rate?: number;
    free_minutes?: number;
    devices?: CreateParkingAreaDevice[];
}
export interface ParkingAreaFilters {
    page?: number;
    limit?: number;
    name?: string;
    type?: ParkingAreaType | ParkingAreaType[];
    min_available_spots?: number;
    max_available_spots?: number;
    sort_by?: 'name' | 'total_spots' | 'available_spots' | 'created_at' | 'updated_at';
    sort_direction?: 'asc' | 'desc';
}
export type ParkingAreaListResponse = PaginatedResponse<ParkingArea>;
export type ParkingAreaQueryParams = Omit<ParkingAreaFilters, 'page' | 'limit'>;
export declare enum UserRole {
    USER = "USER",
    SYSTEM = "SYSTEM",
    TENANT_ADMIN = "TENANT_ADMIN",
    API_USER = "API_USER"
}
export declare enum UserStatus {
    ACTIVE = "ACTIVE",
    INACTIVE = "INACTIVE"
}
export interface User extends BaseEntity {
    date_of_birth?: ISODateString;
    email?: string;
    is_new_user: boolean;
    name?: string;
    numerical_id?: number;
    phone_number?: string;
    photo?: string;
    role: UserRole;
    status: UserStatus;
    surname?: string;
    tenant_id?: UUID;
    relationship_type?: string;
}
export interface UserPublic {
    id: UUID;
    name?: string;
    surname?: string;
    photo?: string;
}
export type CardNumber = `${number}${number}${number}${number}${number}${number}${number}${number}${number}${number}${number}${number}${number}${number}${number}${number}`;
export type dateFormat = `${number}${number}${number}${number}-${number}${number}-${number}${number} ${number}${number}:${number}${number}:${number}${number}`;
export type binQueryType = `${number}${number}${number}${number}${number}${number}`;
export type expiryDateType = `${number}${number}/${number}${number}`;
export type cvcType = `${number}${number}${number}`;
export type expireYearType = `${number}${number}${number}${number}`;
export type expireMonthType = `${number}${number}`;
export interface CardDetails {
    id?: string;
    binNumber?: string;
    lastFourDigits?: string;
    isDefault?: boolean;
    isActive?: boolean;
    cardNumber: CardNumber;
    cardHolderName: string;
    cardExpiryDate: expiryDateType;
    cardCvv: cvcType;
    cardToken?: string;
    cardUserKey?: string;
    cardAlias?: string;
}
export interface UserRegisterParams {
    email?: string;
    password?: string;
    phone_number?: string;
    name?: string;
    surname?: string;
    date_of_birth?: ISODateString;
    tenant_id?: UUID;
}
export interface UserUpdateParams {
    name?: string;
    surname?: string;
    email?: string;
    phone_number?: string;
    date_of_birth?: ISODateString;
    photo?: string;
}
export interface UserPasswordUpdateParams {
    current_password: string;
    new_password: string;
    confirm_password: string;
}
export interface UserLoginParams {
    email: string;
    password: string;
}
export interface UserFilters extends BaseFilters {
    role?: UserRole | UserRole[];
    status?: UserStatus | UserStatus[];
    is_new_user?: boolean;
    tenant_id?: UUID;
}
export interface UserCardFilters extends BaseFilters {
    last_four_digits: string;
    is_default?: boolean;
    is_active?: boolean;
}
export interface BalanceTransaction {
    id: UUID;
    user_id?: UUID;
    type?: string;
    amount?: number | string;
    currency?: string;
    balance_before?: number | string;
    balance_after?: number | string;
    description?: string;
    created_at?: ISODateString;
    [key: string]: any;
}
export interface BalanceTransactionFilters extends PaginationParams {
    type?: string;
    from_date?: ISODateString;
    to_date?: ISODateString;
}
export type UserListResponse = PaginatedResponse<User>;
export type UserCardListResponse = CardDetails[];
export type BalanceTransactionListResponse = PaginatedResponse<BalanceTransaction>;
export interface LicensePlate {
    id: UUID;
    plate_number: string;
    user_id?: UUID;
    created_at?: ISODateString;
    updated_at?: ISODateString;
    [key: string]: any;
}
export interface LicensePlateCreateParams {
    plate_number: string;
}
export type LicensePlateListResponse = LicensePlate[];
export interface LoginResponse {
    token: string;
    user: User;
    expiresIn?: number;
}
export interface OtpRequestParams {
    phone_number?: string;
    email?: string;
}
export interface OtpVerifyParams {
    phone_number?: string;
    email?: string;
    otp_code: string;
}
export interface ApiKeyCreateParams {
    name?: string;
    user_id?: string;
    description?: string;
    expires_at?: ISODateString;
}
export interface TenantConfig {
    payment?: Record<string, any>;
    reservation?: Record<string, any>;
    branding?: {
        logo?: string;
        main_color?: string;
        secondary_color?: string;
    };
}
export interface Tenant extends BaseEntity {
    name: string;
    status: EntityStatus;
    config?: TenantConfig;
    payment_config?: Record<string, any>;
    reservation_config?: Record<string, any>;
    logo?: string;
    main_color?: string;
}
export interface TenantCreateParams {
    name: string;
    status?: EntityStatus;
    config?: TenantConfig;
    payment_config?: Record<string, any>;
    reservation_config?: Record<string, any>;
    logo?: string;
    main_color?: string;
}
export interface TenantUpdateParams {
    name?: string;
    status?: EntityStatus;
    config?: TenantConfig;
    payment_config?: Record<string, any>;
    reservation_config?: Record<string, any>;
    logo?: string;
    main_color?: string;
}
export interface TenantFilters extends BaseFilters {
    name?: string;
    status?: EntityStatus | EntityStatus[];
}
export type TenantListResponse = PaginatedResponse<Tenant>;
export interface TenantUserAssignParams {
    user_id: UUID;
    role: UserRole.TENANT_ADMIN | UserRole.USER;
}
export interface AddOwnerResponse {
    device_id: UUID;
    relationship_type: string;
    status: EntityStatus;
}
export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
export interface RequestOptions {
    headers?: Record<string, string>;
    timeout?: number;
    params?: Record<string, any>;
    [key: string]: any;
}
/**
 * Type guard to check if a value is a valid UUID
 */
export declare function isUUID(value: string): value is UUID;
/**
 * Type guard to check if a value is a valid timestamp
 */
export declare function isTimestamp(value: number): value is Timestamp;
/**
 * Type guard to check if a value is a valid ISO date string
 */
export declare function isISODateString(value: string): value is ISODateString;
/**
 * Helper type for creating filter objects with proper typing
 */
export type FilterValue<T> = T | T[] | undefined;
/**
 * Helper type for API endpoints that return either single items or paginated lists
 */
export type ApiResult<T> = ApiResponse<T> | ApiResponse<PaginatedResponse<T>>;
/**
 * Device UUID type alias for better type safety
 */
export type DeviceUUID = UUID;
/**
 * Device log entry representing a single log record from a device
 * This matches the DeviceLogResponse from the backend
 */
export interface DeviceLog {
    logged_at: Timestamp;
    device_id: DeviceUUID;
    status: string;
    last_seen: Timestamp;
    busy?: boolean;
    blocked?: boolean;
    sensor?: boolean;
    battery?: number;
    alarm_status?: number;
    alarm_description?: string;
    ble_signal?: number;
    gsm_signal?: number;
    source?: 'MQTT' | 'API' | 'BLE' | 'MANUAL';
    command?: string;
    result?: boolean;
}
/**
 * Legacy device log interface for backward compatibility
 * @deprecated Use DeviceLog instead
 */
export interface DeviceLogLegacy extends BaseEntity {
    device_id: UUID;
    timestamp: ISODateString;
    status?: string;
    blocked?: boolean;
    operational_status?: OperationalStatus;
    has_alarm?: boolean;
    data?: Record<string, any>;
    raw_data?: any;
}
/**
 * Query parameters for fetching device logs
 * Supports both ISO date strings and Unix timestamps for flexibility
 */
export interface DeviceLogFilters {
    device_id?: DeviceUUID;
    device_ids?: DeviceUUID[];
    status?: string | string[];
    blocked?: boolean;
    sensor?: boolean;
    has_alarm?: boolean;
    start_time?: ISODateString | Timestamp;
    end_time?: ISODateString | Timestamp;
    limit?: number;
    page?: number;
}
/**
 * Response structure for device logs list
 * This matches the DeviceLogsListResponse from the backend
 */
export interface DeviceLogListResponse {
    data: DeviceLog[];
    pagination: Pagination;
}
/**
 * Query parameters for hourly stats
 */
export interface DeviceLogHourlyStatsParams {
    device_id?: DeviceUUID;
    start_time?: ISODateString | Timestamp;
    end_time?: ISODateString | Timestamp;
    limit?: number;
}
/**
 * Device analytics summary data
 */
export interface DeviceAnalytics {
    device_id: DeviceUUID;
    total_logs: number;
    status_distribution?: Record<string, number>;
    alarm_count?: number;
    blocked_count?: number;
    time_range: {
        start?: ISODateString | Timestamp;
        end?: ISODateString | Timestamp;
    };
    last_activity?: ISODateString | Timestamp;
    [key: string]: any;
}
/**
 * Query parameters for device analytics
 * Supports both ISO date strings and Unix timestamps
 */
export interface DeviceAnalyticsParams {
    start_time?: ISODateString | Timestamp;
    end_time?: ISODateString | Timestamp;
}
/**
 * Device logs count response
 */
export interface DeviceLogCount {
    device_id: DeviceUUID;
    count: number;
    time_range: {
        start?: ISODateString;
        end?: ISODateString;
    };
}
/**
 * Parameters for device logs count requests
 * Supports both ISO date strings and Unix timestamps
 */
export interface DeviceLogCountParams {
    start_time?: ISODateString | Timestamp;
    end_time?: ISODateString | Timestamp;
}
/**
 * Request parameters for cleanup operation
 * Supports both ISO date strings and Unix timestamps
 */
export interface DeviceLogCleanupParams {
    older_than: ISODateString | Timestamp;
}
/**
 * Response from device logs cleanup operation
 * This matches the CleanupOldLogsResponse from the backend
 */
export interface DeviceLogCleanupResponse {
    deleted_count: number;
    cutoff_date: Timestamp;
}
/**
 * QR data information with device details
 */
export interface QrDataInfo extends BaseEntity {
    data: string;
    device_code?: string;
    device_id?: UUID;
    device?: {
        id: UUID;
        nick_name?: string;
        serial_no?: string;
        type?: string;
        status?: EntityStatus;
    };
    is_assigned: boolean;
}
/**
 * QR data creation parameters
 */
export interface QrDataCreateParams {
    qr_data: string;
    device_code?: string;
}
/**
 * QR data update parameters
 */
export interface QrDataUpdateParams {
    qr_data?: string;
    device_code?: string;
}
/**
 * Bulk QR data creation parameters
 */
export interface QrDataBulkCreateParams {
    qr_codes: QrDataCreateParams[];
}
/**
 * QR data assignment parameters
 */
export interface QrDataAssignmentParams {
    qr_data?: string;
    device_code?: string;
    device_id: UUID;
}
/**
 * Bulk QR data assignment parameters
 */
export interface QrDataBulkAssignParams {
    assignments: QrDataAssignmentParams[];
}
/**
 * QR data validation response
 */
export interface QrDataValidationResponse {
    qr_data_exists: boolean;
    device_code_exists: boolean;
    qr_data_assigned: boolean;
    device_code_assigned: boolean;
}
/**
 * QR data filters for listing
 */
export interface QrDataFilters extends BaseFilters {
    is_assigned?: boolean;
    device_id?: UUID;
    sort_by?: 'created_at' | 'updated_at' | 'data' | 'device_code' | 'nick_name' | 'serial_no';
    sort_direction?: 'asc' | 'desc';
}
/**
 * Device QR summary statistics
 */
export interface DeviceQrSummary {
    total_devices: number;
    devices_with_qr: number;
    devices_without_qr: number;
    total_qr_codes: number;
    assigned_qr_codes: number;
    unassigned_qr_codes: number;
}
/**
 * QR data creation/assignment response
 */
export interface QrDataOperationResponse {
    created?: number;
    assigned?: number;
    total_requested: number;
    errors: string[];
}
/**
 * Device found by QR data response
 */
export interface DeviceByQrResponse {
    id: UUID;
    type: string;
    nick_name: string;
    serial_no: string;
    description?: string;
    notes?: string;
    location?: string;
    geo_lat?: number;
    geo_lng?: number;
    status: EntityStatus;
    qr_data?: string;
    device_code?: string;
}
/**
 * Payment type enumeration
 */
export declare enum PaymentType {
    PRE_AUTH = "PRE_AUTH",
    POST_AUTH = "POST_AUTH",
    SALE = "SALE",
    REFUND = "REFUND"
}
/**
 * Payment status enumeration
 */
export declare enum PaymentStatus {
    PENDING_PRE_AUTH = "PENDING_PRE_AUTH",
    PRE_AUTH_SUCCESS = "PRE_AUTH_SUCCESS",
    PRE_AUTH_FAILED = "PRE_AUTH_FAILED",
    PENDING_CAPTURE = "PENDING_CAPTURE",
    CAPTURED = "CAPTURED",
    CAPTURE_FAILED = "CAPTURE_FAILED",
    SALE_FAILED = "SALE_FAILED",
    PENDING_REFUND = "PENDING_REFUND",
    REFUND_SUCCESS = "REFUND_SUCCESS",
    REFUND_FAILED = "REFUND_FAILED",
    FAILED = "FAILED"
}
/**
 * Payment entity interface
 */
export interface Payment {
    id: number;
    user_id: UUID;
    parking_id?: UUID;
    method: string;
    payment_type: PaymentType;
    conversation_id?: string;
    transaction_id?: string;
    amount: string;
    currency: string;
    card_token?: string;
    card_user_key?: string;
    status: PaymentStatus;
    error_code?: string;
    error_message?: string;
    gateway_response?: Record<string, any>;
    created_at: ISODateString;
    updated_at: ISODateString;
}
/**
 * Payment filters for listing payments
 */
export interface PaymentFilters extends BaseFilters {
    tenant_id?: UUID;
    user_id?: UUID;
    currency?: string;
    min_amount?: number;
    max_amount?: number;
    payment_type?: PaymentType | PaymentType[];
    status?: PaymentStatus | PaymentStatus[];
    conversation_id?: string;
    sort_by?: 'amount' | 'created_at' | 'updated_at';
    sort_direction?: 'asc' | 'desc';
}
/**
 * Payment list response type
 */
export type PaymentListResponse = PaginatedResponse<Payment>;
export interface InvoiceItem {
    id?: UUID;
    name?: string;
    description?: string;
    quantity?: number;
    unit_price?: number | string;
    total_price?: number | string;
    tax_rate?: number;
    tax_amount?: number | string;
    [key: string]: any;
}
export declare enum InvoiceStatus {
    UNPAID = "UNPAID",
    PAID = "PAID",
    VOID = "VOID"
}
export interface InvoiceSummaryUser {
    name?: string | null;
    surname?: string | null;
    email?: string | null;
    phone_number?: string | null;
}
export interface Invoice extends BaseEntity {
    user_id: UUID;
    parking_id?: UUID | null;
    membership_id?: UUID | null;
    payment_id?: UUID | null;
    amount: string;
    currency: string;
    status: InvoiceStatus;
    issued_at: ISODateString;
    paid_at?: ISODateString | null;
    user?: InvoiceSummaryUser | null;
    tenant_id?: UUID;
    invoice_number?: string;
    subtotal?: number | string;
    tax_amount?: number | string;
    total_amount?: number | string;
    due_date?: ISODateString;
    notes?: string;
    items?: InvoiceItem[];
    metadata?: Record<string, any>;
    [key: string]: any;
}
export interface InvoiceFilters extends BaseFilters {
    user_id?: UUID;
    tenant_id?: UUID;
    status?: InvoiceStatus | InvoiceStatus[];
    sort_by?: 'issued_at' | 'amount' | 'status' | 'currency';
    sort_direction?: 'asc' | 'desc';
}
export interface InvoiceCreateParams {
    user_id: UUID;
    amount: number;
    currency: string;
    parking_id?: UUID | null;
    membership_id?: UUID | null;
    payment_id?: UUID | null;
    status?: InvoiceStatus;
    paid_at?: ISODateString | null;
    tenant_id?: UUID;
    invoice_number?: string;
    subtotal?: number | string;
    tax_amount?: number | string;
    total_amount?: number | string;
    issued_at?: ISODateString;
    due_date?: ISODateString;
    notes?: string;
    items?: InvoiceItem[];
    metadata?: Record<string, any>;
    [key: string]: any;
}
export interface InvoiceUpdateParams {
    status?: InvoiceStatus;
    paid_at?: ISODateString | null;
    payment_id?: UUID | null;
    amount?: number;
    currency?: string;
    [key: string]: any;
}
export type InvoiceListResponse = PaginatedResponse<Invoice>;
export type ComponentStatus = 'UP' | 'DOWN' | 'UNKNOWN';
export interface ComponentHealth {
    status: ComponentStatus;
    response_time_ms: number;
    message?: string;
    [key: string]: any;
}
export interface HealthCheckData {
    overall_status: ComponentStatus;
    components: {
        api: ComponentHealth;
        database: ComponentHealth;
        mqtt: ComponentHealth;
        sms: ComponentHealth;
        payment: ComponentHealth;
        tcp: ComponentHealth;
    };
}
/**
 * @deprecated Use DeviceLogFilters instead
 */
export interface DeviceLogFiltersLegacy extends BaseFilters {
    device_id?: UUID;
    device_ids?: UUID[];
    status?: string[];
    blocked?: boolean;
    has_alarm?: boolean;
    start_time?: ISODateString;
    end_time?: ISODateString;
    limit?: number;
    offset?: number;
}