@northern.tech/store 0.46.4 → 0.47.0

package/dist/selectors-1394DVvN.d.ts

@@ -0,0 +1,712 @@
+import { c as DeviceSliceType, i as DeviceGroup, l as DeviceTierLimits, o as DeviceListState, r as DeviceFilter, t as Device } from "./index-DOPRnlaC.js";
+//#region src/devicesSlice/selectors.d.ts
+type DevicesState = {
+  devices: DeviceSliceType;
+};
+declare const getAcceptedDevices: (state: DevicesState) => {
+  counts: DeviceTierLimits & {
+    total: number;
+  };
+  deviceIds: string[];
+};
+declare const getDevicesByStatus: (state: DevicesState) => Record<string, {
+  counts: DeviceTierLimits & {
+    total: number;
+  };
+  deviceIds: string[];
+}>;
+declare const getDevicesById: (state: DevicesState) => Record<string, Device>;
+declare const getDeviceReports: (state: DevicesState) => {
+  items: {
+    count: number;
+    key: string;
+  }[];
+  otherCount: number;
+  total: number;
+}[];
+declare const getGroupsById: (state: DevicesState) => Record<string, DeviceGroup>;
+declare const getSelectedGroup: (state: DevicesState) => string | undefined;
+declare const getDeviceListState: (state: DevicesState) => DeviceListState;
+declare const getListedDevices: (state: DevicesState) => string[];
+declare const getFilteringAttributes: (state: DevicesState) => {
+  identityAttributes: string[];
+  inventoryAttributes: string[];
+  systemAttributes: string[];
+  tagAttributes: string[];
+};
+declare const getDeviceFilters: (state: DevicesState) => DeviceFilter[];
+declare const getTestDeviceLimit: (state: DevicesState) => number;
+declare const getSortedFilteringAttributes: ((state: DevicesState) => {
+  identityAttributes: string[];
+  inventoryAttributes: string[];
+  systemAttributes: string[];
+  tagAttributes: string[];
+}) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    identityAttributes: string[];
+    inventoryAttributes: string[];
+    systemAttributes: string[];
+    tagAttributes: string[];
+  }) => {
+    identityAttributes: string[];
+    inventoryAttributes: string[];
+    systemAttributes: string[];
+    tagAttributes: string[];
+  };
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    identityAttributes: string[];
+    inventoryAttributes: string[];
+    systemAttributes: string[];
+    tagAttributes: string[];
+  }) => {
+    identityAttributes: string[];
+    inventoryAttributes: string[];
+    systemAttributes: string[];
+    tagAttributes: string[];
+  }) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => {
+    identityAttributes: string[];
+    inventoryAttributes: string[];
+    systemAttributes: string[];
+    tagAttributes: string[];
+  };
+  dependencies: [(state: DevicesState) => {
+    identityAttributes: string[];
+    inventoryAttributes: string[];
+    systemAttributes: string[];
+    tagAttributes: string[];
+  }];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  memoize: typeof import("reselect").weakMapMemoize;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const getDeviceLimits: (state: DevicesState) => DeviceTierLimits;
+declare const getTestDeviceCount: (state: DevicesState) => number;
+declare const getDeviceIdentityAttributes: ((state: DevicesState) => {
+  value: string;
+  label: string;
+  scope: string;
+}[]) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    identityAttributes: string[];
+    inventoryAttributes: string[];
+    systemAttributes: string[];
+    tagAttributes: string[];
+  }, resultFuncArgs_1: number) => {
+    value: string;
+    label: string;
+    scope: string;
+  }[];
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    identityAttributes: string[];
+    inventoryAttributes: string[];
+    systemAttributes: string[];
+    tagAttributes: string[];
+  }, resultFuncArgs_1: number) => {
+    value: string;
+    label: string;
+    scope: string;
+  }[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => {
+    value: string;
+    label: string;
+    scope: string;
+  }[];
+  dependencies: [(state: DevicesState) => {
+    identityAttributes: string[];
+    inventoryAttributes: string[];
+    systemAttributes: string[];
+    tagAttributes: string[];
+  }, (state: DevicesState) => number];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  memoize: typeof import("reselect").weakMapMemoize;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const getDeviceCountsByStatus: ((state: DevicesState) => Record<string, number>) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: Record<string, {
+    counts: DeviceTierLimits & {
+      total: number;
+    };
+    deviceIds: string[];
+  }>) => Record<string, number>;
+  memoizedResultFunc: ((resultFuncArgs_0: Record<string, {
+    counts: DeviceTierLimits & {
+      total: number;
+    };
+    deviceIds: string[];
+  }>) => Record<string, number>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => Record<string, number>;
+  dependencies: [(state: DevicesState) => Record<string, {
+    counts: DeviceTierLimits & {
+      total: number;
+    };
+    deviceIds: string[];
+  }>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  memoize: typeof import("reselect").weakMapMemoize;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const getDeviceById: ((state: any, deviceId: any) => Device) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: Record<string, Device>, resultFuncArgs_1: any) => Device;
+  memoizedResultFunc: ((resultFuncArgs_0: Record<string, Device>, resultFuncArgs_1: any) => Device) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => Device;
+  dependencies: [(state: DevicesState) => Record<string, Device>, (_: any, deviceId: any) => any];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  memoize: typeof import("reselect").weakMapMemoize;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const getSelectedGroupInfo: ((state: DevicesState) => {
+  groupCount: number;
+  selectedGroup: string | undefined;
+  groupFilters: DeviceFilter[];
+}) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: Record<string, number>, resultFuncArgs_1: Record<string, DeviceGroup>, resultFuncArgs_2: string | undefined) => {
+    groupCount: number;
+    selectedGroup: string | undefined;
+    groupFilters: DeviceFilter[];
+  };
+  memoizedResultFunc: ((resultFuncArgs_0: Record<string, number>, resultFuncArgs_1: Record<string, DeviceGroup>, resultFuncArgs_2: string | undefined) => {
+    groupCount: number;
+    selectedGroup: string | undefined;
+    groupFilters: DeviceFilter[];
+  }) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => {
+    groupCount: number;
+    selectedGroup: string | undefined;
+    groupFilters: DeviceFilter[];
+  };
+  dependencies: [((state: DevicesState) => Record<string, number>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: Record<string, {
+      counts: DeviceTierLimits & {
+        total: number;
+      };
+      deviceIds: string[];
+    }>) => Record<string, number>;
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, {
+      counts: DeviceTierLimits & {
+        total: number;
+      };
+      deviceIds: string[];
+    }>) => Record<string, number>) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => Record<string, number>;
+    dependencies: [(state: DevicesState) => Record<string, {
+      counts: DeviceTierLimits & {
+        total: number;
+      };
+      deviceIds: string[];
+    }>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+  }, (state: DevicesState) => Record<string, DeviceGroup>, (state: DevicesState) => string | undefined];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  memoize: typeof import("reselect").weakMapMemoize;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const getCombinedLimit: ((state: DevicesState) => number) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: DeviceTierLimits) => number;
+  memoizedResultFunc: ((resultFuncArgs_0: DeviceTierLimits) => number) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => number;
+  dependencies: [(state: DevicesState) => DeviceTierLimits];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  memoize: typeof import("reselect").weakMapMemoize;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const getLimitMaxed: ((state: DevicesState) => boolean) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: Record<string, number>, resultFuncArgs_1: number) => boolean;
+  memoizedResultFunc: ((resultFuncArgs_0: Record<string, number>, resultFuncArgs_1: number) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => boolean;
+  dependencies: [((state: DevicesState) => Record<string, number>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: Record<string, {
+      counts: DeviceTierLimits & {
+        total: number;
+      };
+      deviceIds: string[];
+    }>) => Record<string, number>;
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, {
+      counts: DeviceTierLimits & {
+        total: number;
+      };
+      deviceIds: string[];
+    }>) => Record<string, number>) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => Record<string, number>;
+    dependencies: [(state: DevicesState) => Record<string, {
+      counts: DeviceTierLimits & {
+        total: number;
+      };
+      deviceIds: string[];
+    }>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+  }, ((state: DevicesState) => number) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: DeviceTierLimits) => number;
+    memoizedResultFunc: ((resultFuncArgs_0: DeviceTierLimits) => number) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => number;
+    dependencies: [(state: DevicesState) => DeviceTierLimits];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+  }];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  memoize: typeof import("reselect").weakMapMemoize;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const getGroupsByIdWithoutUngrouped: ((state: DevicesState) => {
+  [x: string]: DeviceGroup;
+}) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: Record<string, DeviceGroup>) => {
+    [x: string]: DeviceGroup;
+  };
+  memoizedResultFunc: ((resultFuncArgs_0: Record<string, DeviceGroup>) => {
+    [x: string]: DeviceGroup;
+  }) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => {
+    [x: string]: DeviceGroup;
+  };
+  dependencies: [(state: DevicesState) => Record<string, DeviceGroup>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  memoize: typeof import("reselect").weakMapMemoize;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const getGroupData: ((state: DevicesState) => {
+  createdGroup: string | undefined;
+  hasDynamicGroups: boolean;
+  groups: {
+    [x: string]: DeviceGroup;
+  };
+}) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    [x: string]: DeviceGroup;
+  }) => {
+    createdGroup: string | undefined;
+    hasDynamicGroups: boolean;
+    groups: {
+      [x: string]: DeviceGroup;
+    };
+  };
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    [x: string]: DeviceGroup;
+  }) => {
+    createdGroup: string | undefined;
+    hasDynamicGroups: boolean;
+    groups: {
+      [x: string]: DeviceGroup;
+    };
+  }) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => {
+    createdGroup: string | undefined;
+    hasDynamicGroups: boolean;
+    groups: {
+      [x: string]: DeviceGroup;
+    };
+  };
+  dependencies: [((state: DevicesState) => {
+    [x: string]: DeviceGroup;
+  }) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: Record<string, DeviceGroup>) => {
+      [x: string]: DeviceGroup;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, DeviceGroup>) => {
+      [x: string]: DeviceGroup;
+    }) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => {
+      [x: string]: DeviceGroup;
+    };
+    dependencies: [(state: DevicesState) => Record<string, DeviceGroup>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+  }];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  memoize: typeof import("reselect").weakMapMemoize;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+type SelectorGroup = DeviceGroup & {
+  groupId: string;
+};
+declare const getGroups: ((state: DevicesState) => {
+  dynamic: SelectorGroup[];
+  static: SelectorGroup[];
+  ungrouped: SelectorGroup[];
+  groupNames: string[];
+}) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: Record<string, DeviceGroup>) => {
+    dynamic: SelectorGroup[];
+    static: SelectorGroup[];
+    ungrouped: SelectorGroup[];
+    groupNames: string[];
+  };
+  memoizedResultFunc: ((resultFuncArgs_0: Record<string, DeviceGroup>) => {
+    dynamic: SelectorGroup[];
+    static: SelectorGroup[];
+    ungrouped: SelectorGroup[];
+    groupNames: string[];
+  }) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => {
+    dynamic: SelectorGroup[];
+    static: SelectorGroup[];
+    ungrouped: SelectorGroup[];
+    groupNames: string[];
+  };
+  dependencies: [(state: DevicesState) => Record<string, DeviceGroup>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  memoize: typeof import("reselect").weakMapMemoize;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const getAttributesList: ((state: DevicesState) => string[]) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    identityAttributes: string[];
+    inventoryAttributes: string[];
+    systemAttributes: string[];
+    tagAttributes: string[];
+  }, resultFuncArgs_1: Record<string, string[]>) => string[];
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    identityAttributes: string[];
+    inventoryAttributes: string[];
+    systemAttributes: string[];
+    tagAttributes: string[];
+  }, resultFuncArgs_1: Record<string, string[]>) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => string[];
+  dependencies: [(state: DevicesState) => {
+    identityAttributes: string[];
+    inventoryAttributes: string[];
+    systemAttributes: string[];
+    tagAttributes: string[];
+  }, (state: DevicesState) => Record<string, string[]>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  memoize: typeof import("reselect").weakMapMemoize;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const getEnabledTiers: ((state: DevicesState) => string[]) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: [string, number][]) => string[];
+  memoizedResultFunc: ((resultFuncArgs_0: [string, number][]) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => string[];
+  dependencies: [((state: DevicesState) => [string, number][]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: DeviceTierLimits) => [string, number][];
+    memoizedResultFunc: ((resultFuncArgs_0: DeviceTierLimits) => [string, number][]) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => [string, number][];
+    dependencies: [(state: DevicesState) => DeviceTierLimits];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+  }];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  memoize: typeof import("reselect").weakMapMemoize;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const getDeviceLimitStats: ((state: DevicesState) => {
+  type: string;
+  limit: number;
+  total: any;
+}[]) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: [string, number][], resultFuncArgs_1: {
+    counts: DeviceTierLimits & {
+      total: number;
+    };
+    deviceIds: string[];
+  }) => {
+    type: string;
+    limit: number;
+    total: any;
+  }[];
+  memoizedResultFunc: ((resultFuncArgs_0: [string, number][], resultFuncArgs_1: {
+    counts: DeviceTierLimits & {
+      total: number;
+    };
+    deviceIds: string[];
+  }) => {
+    type: string;
+    limit: number;
+    total: any;
+  }[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => {
+    type: string;
+    limit: number;
+    total: any;
+  }[];
+  dependencies: [((state: DevicesState) => [string, number][]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  } & {
+    resultFunc: (resultFuncArgs_0: DeviceTierLimits) => [string, number][];
+    memoizedResultFunc: ((resultFuncArgs_0: DeviceTierLimits) => [string, number][]) & {
+      clearCache: () => void;
+      resultsCount: () => number;
+      resetResultsCount: () => void;
+    };
+    lastResult: () => [string, number][];
+    dependencies: [(state: DevicesState) => DeviceTierLimits];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+  } & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+  }, (state: DevicesState) => {
+    counts: DeviceTierLimits & {
+      total: number;
+    };
+    deviceIds: string[];
+  }];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  memoize: typeof import("reselect").weakMapMemoize;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const getDeviceTypes: ((state: DevicesState) => string[]) & {
+  clearCache: () => void;
+  resultsCount: () => number;
+  resetResultsCount: () => void;
+} & {
+  resultFunc: (resultFuncArgs_0: {
+    counts: DeviceTierLimits & {
+      total: number;
+    };
+    deviceIds: string[];
+  }, resultFuncArgs_1: Record<string, Device>) => string[];
+  memoizedResultFunc: ((resultFuncArgs_0: {
+    counts: DeviceTierLimits & {
+      total: number;
+    };
+    deviceIds: string[];
+  }, resultFuncArgs_1: Record<string, Device>) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+  };
+  lastResult: () => string[];
+  dependencies: [(state: DevicesState) => {
+    counts: DeviceTierLimits & {
+      total: number;
+    };
+    deviceIds: string[];
+  }, (state: DevicesState) => Record<string, Device>];
+  recomputations: () => number;
+  resetRecomputations: () => void;
+  dependencyRecomputations: () => number;
+  resetDependencyRecomputations: () => void;
+} & {
+  memoize: typeof import("reselect").weakMapMemoize;
+  argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+//#endregion
+export { getListedDevices as C, getTestDeviceCount as D, getSortedFilteringAttributes as E, getTestDeviceLimit as O, getLimitMaxed as S, getSelectedGroupInfo as T, getFilteringAttributes as _, getDeviceById as a, getGroupsById as b, getDeviceIdentityAttributes as c, getDeviceListState as d, getDeviceReports as f, getEnabledTiers as g, getDevicesByStatus as h, getCombinedLimit as i, getDeviceLimitStats as l, getDevicesById as m, getAcceptedDevices as n, getDeviceCountsByStatus as o, getDeviceTypes as p, getAttributesList as r, getDeviceFilters as s, DevicesState as t, getDeviceLimits as u, getGroupData as v, getSelectedGroup as w, getGroupsByIdWithoutUngrouped as x, getGroups as y };
+//# sourceMappingURL=selectors-1394DVvN.d.ts.map