@bitbar/cloud-api-client 0.55.1 → 1.0.1

package/dist/API.d.ts

@@ -1,38 +1,66 @@
-import './finka';
-import ApiConfig from './ApiConfig';
-import { AxiosInstance } from 'axios';
-import APIList from './api/APIList';
-import APIListDevices from './api/APIListDevices';
-import APIListUsers from './api/APIListUsers';
-import APIResourceUser from './api/APIResourceUser';
-import APIResourceDevice from './api/APIResourceDevice';
-import APIResourceDeviceGroup from './api/APIResourceDeviceGroup';
-import APIResourceUserSession from './api/APIResourceUserSession';
-import APIAdminResource from './api/APIAdminResource';
-import APIResourceAccount from './api/APIResourceAccount';
-import APIResource from "./api/APIResource";
-import APIResourceDeviceSession from "./api/APIResourceDeviceSession";
-declare class API {
-    private config;
-    private axiosConfig;
-    axios: AxiosInstance;
-    constructor(config: ApiConfig);
-    userSession(): APIResourceUserSession;
-    user(id: number | 'me'): APIResourceUser;
-    users(): APIListUsers;
-    account(id: number): APIResourceAccount;
-    me(): APIResourceUser;
-    admin(): APIAdminResource;
-    devices(): APIListDevices;
-    device(id: number): APIResourceDevice;
-    deviceGroups(): APIList;
-    deviceGroup(id: number): APIResourceDeviceGroup;
-    deviceSessions(): APIList;
-    deviceSession(id: number): APIResourceDeviceSession;
-    labelGroups(): APIList;
-    deviceStatistics(): APIList;
-    enums(): APIResource;
-    licenses(): APIResource;
-    labels(): APIList;
-}
-export default API;
+import { AxiosInstance } from 'axios';
+import { APIAdminResource } from './api/APIAdminResource';
+import { APIAdminResourceCluster } from './api/APIAdminResourceCluster';
+import { APIList } from './api/APIList';
+import { APIListDevices } from './api/APIListDevices';
+import { APIListProperties } from './api/APIListProperties';
+import { APIListServices } from './api/APIListServices';
+import { APIListUsers } from './api/APIListUsers';
+import { APIResource } from './api/APIResource';
+import { APIResourceAccount } from './api/APIResourceAccount';
+import { APIResourceBroker } from './api/APIResourceBroker';
+import { APIResourceDevice } from './api/APIResourceDevice';
+import { APIResourceDeviceGroup } from './api/APIResourceDeviceGroup';
+import { APIResourceDeviceSession } from './api/APIResourceDeviceSession';
+import { APIResourceFile } from './api/APIResourceFile';
+import { APIResourceLabelGroup } from './api/APIResourceLabelGroup';
+import { APIResourceProject } from './api/APIResourceProject';
+import { APIResourceRun } from './api/APIResourceRun';
+import { APIResourceUser } from './api/APIResourceUser';
+import { APIResourceUserSession } from './api/APIResourceUserSession';
+import { Cluster } from './api/models/Cluster';
+import { NoQueryParams } from './api/models/HTTP';
+import { License } from './api/models/License';
+import { Project } from './api/models/Project';
+import { Property } from './api/models/Property';
+import { UserFile, UserFileData, UserFileParams } from './api/models/UserFile';
+import { ApiConfig } from './ApiConfig';
+import './finka';
+export declare class API {
+    private config;
+    axios: AxiosInstance;
+    private axiosConfig;
+    get baseUrl(): string;
+    constructor(config: ApiConfig);
+    account(id: number): APIResourceAccount;
+    admin(): APIAdminResource;
+    broker(): APIResourceBroker;
+    clusters(): APIList<Cluster, import("./api/models/HTTP").CollectionQueryParams, any>;
+    cluster(id: number): APIAdminResourceCluster;
+    device(id: number): APIResourceDevice;
+    deviceGroup(id: number): APIResourceDeviceGroup;
+    deviceGroups(): APIList<any, import("./api/models/HTTP").CollectionQueryParams, any>;
+    devices(): APIListDevices;
+    deviceSession(id: number): APIResourceDeviceSession;
+    deviceSessions(): APIList<any, import("./api/models/HTTP").CollectionQueryParams, any>;
+    deviceStatistics(): APIList<any, import("./api/models/HTTP").CollectionQueryParams, any>;
+    enums(): APIResource<any, import("./api/models/HTTP").QueryParams, import("./api/models/HTTP").QueryParams>;
+    files(): APIList<UserFile, UserFileParams, UserFileData>;
+    file(id: number): APIResourceFile;
+    labelGroups(): APIList<any, import("./api/models/HTTP").CollectionQueryParams, any>;
+    labelGroup(id: number): APIResourceLabelGroup;
+    labels(): APIList<any, import("./api/models/HTTP").CollectionQueryParams, any>;
+    licenses(): APIResource<any, import("./api/models/HTTP").QueryParams, import("./api/models/HTTP").QueryParams>;
+    license(): APIResource<License, NoQueryParams, void>;
+    me(): APIResourceUser;
+    projects(): APIList<Project, import("./api/models/HTTP").CollectionQueryParams, any>;
+    project(id: number): APIResourceProject;
+    properties(): APIListProperties;
+    property(id: number): APIResource<Property, import("./api/models/HTTP").QueryParams, import("./api/models/HTTP").QueryParams>;
+    run(id: number): APIResourceRun;
+    services(): APIListServices;
+    user(id: number | 'me'): APIResourceUser;
+    users(): APIListUsers;
+    userSession(): APIResourceUserSession;
+}
+export default API;

package/dist/ApiConfig.d.ts

@@ -1,10 +1,10 @@
-import { AxiosBasicCredentials } from 'axios';
-interface ApiConfig {
-    baseURL: string;
-    cloudUrl?: string;
-    v2?: boolean;
-    apiKey?: string;
-    auth?: AxiosBasicCredentials;
-    withCredentials?: boolean;
-}
-export default ApiConfig;
+import { AxiosBasicCredentials } from 'axios';
+export declare type ApiConfig = {
+    baseURL: string;
+    cloudUrl: string;
+    v2?: boolean;
+    apiKey?: string;
+    auth?: AxiosBasicCredentials;
+    withCredentials?: boolean;
+};
+export default ApiConfig;

package/dist/CloudAPIClient.d.ts

@@ -1,7 +1,7 @@
-import API from './API';
-import FilterBuilder from './FilterBuilder';
-declare const CloudAPIClient: {
-    API: typeof API;
-    FilterBuilder: typeof FilterBuilder;
-};
-export default CloudAPIClient;
+import { API } from './API';
+import { FilterBuilder } from './FilterBuilder';
+export declare const CloudAPIClient: {
+    API: typeof API;
+    FilterBuilder: typeof FilterBuilder;
+};
+export default CloudAPIClient;

package/dist/Filter.d.ts

@@ -1,7 +1,7 @@
-declare class Filter {
-    name: string;
-    value: any;
-    operand: string;
-    constructor(name: string, value: any, operand: string);
-}
-export default Filter;
+export declare class Filter<T = any> {
+    name: string;
+    value: T;
+    operand: string;
+    constructor(name: string, value: T, operand: string);
+}
+export default Filter;

package/dist/FilterBuilder.d.ts

@@ -1,25 +1,24 @@
-import './finka';
-import Filter from './Filter';
-declare class FilterBuilder {
-    private filters;
-    constructor();
-    private add;
-    gt(name: string, value: number): FilterBuilder;
-    lt(name: string, value: number): FilterBuilder;
-    after(name: string, value: Date | number): FilterBuilder;
-    afterorequal(name: string, value: Date | number): FilterBuilder;
-    before(name: string, value: Date | number): FilterBuilder;
-    beforeorequal(name: string, value: Date | number): FilterBuilder;
-    on(name: string, value: any): FilterBuilder;
-    eq(name: string, value: any): FilterBuilder;
-    contains(name: string, value: string): FilterBuilder;
-    like(name: string, value: string): FilterBuilder;
-    notlike(name: string, value: string): FilterBuilder;
-    isnull(name: string): FilterBuilder;
-    in(name: string, value: Array<any>): FilterBuilder;
-    notin(name: string, value: Array<any>): FilterBuilder;
-    raw(filter: Filter): void;
-    isFilterPart(str: string): boolean;
-    toString(): string;
-}
-export default FilterBuilder;
+import { Filter } from './Filter';
+import './finka';
+export declare class FilterBuilder {
+    private readonly filters;
+    gt(name: string, value: number): this;
+    lt(name: string, value: number): this;
+    after(name: string, value: Date | number): this;
+    afterorequal(name: string, value: Date | number): this;
+    before(name: string, value: Date | number): this;
+    beforeorequal(name: string, value: Date | number): this;
+    on(name: string, value: any): this;
+    eq(name: string, value: any): this;
+    contains(name: string, value: string): this;
+    like(name: string, value: string): this;
+    notlike(name: string, value: string): this;
+    isnull(name: string): this;
+    in(name: string, value: Array<any>): this;
+    notin(name: string, value: Array<any>): this;
+    raw(filter: Filter | string | Filter[] | string[]): void;
+    isFilterPart(str: string): boolean;
+    toString(): string;
+    private add;
+}
+export default FilterBuilder;

package/dist/api/APIAdminListDevices.d.ts

@@ -1,12 +1,12 @@
-import APIList from './APIList';
-import APIResource from './APIResource';
-import APIListCleanupConfigurations from "./APIListCleanupConfigurations";
-import APIResourceCleanupConfiguration from "./APIResourceCleanupConfiguration";
-declare class APIAdminListDevices extends APIList {
-    constructor(parent: object);
-    filters(): APIResource;
-    cleanupConfigurations(): APIListCleanupConfigurations;
-    cleanupConfiguration(id: number): APIResourceCleanupConfiguration;
-    desktopBrowserCapabilities(): APIResource;
-}
-export default APIAdminListDevices;
+import { API } from '../API';
+import { APIAdminResource } from './APIAdminResource';
+import { APIList } from './APIList';
+import { APIListCleanupConfigurations } from './APIListCleanupConfigurations';
+import { APIResourceCleanupConfiguration } from './APIResourceCleanupConfiguration';
+import { AdminDevice, AdminDeviceData, AdminDevicesQueryParams } from './models/AdminDevice';
+export declare class APIAdminListDevices extends APIList<AdminDevice, AdminDevicesQueryParams, AdminDeviceData> {
+    constructor(parent: APIAdminResource | API);
+    cleanupConfigurations(): APIListCleanupConfigurations;
+    cleanupConfiguration(id: number): APIResourceCleanupConfiguration;
+}
+export default APIAdminListDevices;

package/dist/api/APIAdminListNotificationPlans.d.ts

@@ -1,7 +1,11 @@
-import APIList from './APIList';
-declare class APIAdminListNotificationPlans extends APIList {
-    constructor(parent: object);
-    channels(): APIList;
-    scopes(): APIList;
-}
-export default APIAdminListNotificationPlans;
+import { APIAdminResource } from './APIAdminResource';
+import { APIList } from './APIList';
+import { Enum } from './models/Enum';
+import { CollectionQueryParams, NoQueryParams } from './models/HTTP';
+import { NotificationPlan, NotificationPlanData } from './models/NotificationPlan';
+export declare class APIAdminListNotificationPlans extends APIList<NotificationPlan, CollectionQueryParams, NotificationPlanData> {
+    constructor(parent: APIAdminResource);
+    channels(): APIList<Enum, NoQueryParams, void>;
+    scopes(): APIList<Enum, NoQueryParams, void>;
+}
+export default APIAdminListNotificationPlans;

package/dist/api/APIAdminListRuns.d.ts

@@ -1,7 +1,14 @@
-import APIList from './APIList';
-import APIResource from './APIResource';
-declare class APIAdminListRuns extends APIList {
-    constructor(parent: object);
-    config(): APIResource;
-}
-export default APIAdminListRuns;
+import { Method } from 'axios';
+import { APIAdminResource } from './APIAdminResource';
+import { APIList } from './APIList';
+import { APIResource } from './APIResource';
+import { AdminTestRun, RunsConfigParams } from './models/AdminTestRun';
+import { TestRunConfig } from './models/TestRun';
+export declare class APIAdminListRuns extends APIList<AdminTestRun> {
+    protected ALLOWED_HTTP_METHODS: Array<Method>;
+    constructor(parent: APIAdminResource);
+    config(): APIResource<TestRunConfig, RunsConfigParams, {
+        configuration: TestRunConfig;
+    }>;
+}
+export default APIAdminListRuns;

package/dist/api/APIAdminListServices.d.ts

@@ -1,12 +1,11 @@
-import APIList from './APIList';
-import APIListPurchased from './APIListPurchased';
-declare class APIAdminListServices extends APIList {
-    constructor(parent: object);
-    purchased(): APIListPurchased;
-    available(): APIList;
-    active(): APIList;
-    activated(): APIList;
-    inUse(): APIList;
-    byPrice(): APIList;
-}
-export default APIAdminListServices;
+import { APIAdminResource } from './APIAdminResource';
+import { APIList } from './APIList';
+import { AdminServicesParams, Service } from './models/Service';
+export declare class APIAdminListServices extends APIList<Service, AdminServicesParams, Service> {
+    constructor(parent: APIAdminResource);
+    active(): APIList<Service, AdminServicesParams, Service>;
+    activated(): APIList<Service, AdminServicesParams, Service>;
+    inUse(): APIList<Service, AdminServicesParams, Service>;
+    byPrice(): APIList<Service, AdminServicesParams, Service>;
+}
+export default APIAdminListServices;

package/dist/api/APIAdminListStatistics.d.ts

@@ -1,7 +1,10 @@
-import APIList from './APIList';
-declare class APIAdminListStatistics extends APIList {
-    constructor(parent: object);
-    deviceSessions(): APIList;
-    frameworks(): APIList;
-}
-export default APIAdminListStatistics;
+import { APIAdminResource } from './APIAdminResource';
+import { APIList } from './APIList';
+import { AdminDeviceSessionStatistics, AdminStatisticsParams } from './models/AdminDeviceSessionStatistics';
+import { AdminFrameworkStatistics } from './models/AdminFrameworkStatistics';
+export declare class APIAdminListStatistics extends APIList {
+    constructor(parent: APIAdminResource);
+    deviceSessions(): APIList<AdminDeviceSessionStatistics, AdminStatisticsParams, void>;
+    frameworks(): APIList<AdminFrameworkStatistics, AdminStatisticsParams, void>;
+}
+export default APIAdminListStatistics;

package/dist/api/APIAdminResource.d.ts

@@ -1,91 +1,121 @@
-import APIList from './APIList';
-import APIResource from './APIResource';
-import APIResourceFile from './APIResourceFile';
-import APIResourceProject from './APIResourceProject';
-import APIResourceAccessGroup from './APIResourceAccessGroup';
-import APIAdminListRuns from './APIAdminListRuns';
-import APIAdminResourceCluster from './APIAdminResourceCluster';
-import APIAdminResourceDeviceTime from './APIAdminResourceDeviceTime';
-import APIAdminResourceRunStandalone from './APIAdminResourceRunStandalone';
-import APIAdminResourceDevice from './APIAdminResourceDevice';
-import APIAdminResourceAccountService from './APIAdminResourceAccountService';
-import APIAdminResourceUser from './APIAdminResourceUser';
-import APIAdminResourceDeviceSessionStandalone from './APIAdminResourceDeviceSessionStandalone';
-import APIAdminListDevices from "./APIAdminListDevices";
-import APIResourceDeviceGroup from "./APIResourceDeviceGroup";
-import APIAdminResourceFramework from "./APIAdminResourceFramework";
-import APIAdminResourceLicense from "./APIAdminResourceLicense";
-import APIAdminListNotificationPlans from "./APIAdminListNotificationPlans";
-import APIAdminResourceNotificationPlan from "./APIAdminResourceNotificationPlan";
-import APIAdminResourceService from "./APIAdminResourceService";
-import APIAdminListServices from "./APIAdminListServices";
-import APIAdminListStatistics from "./APIAdminListStatistics";
-import APIAdminResourceDeviceModel from "./APIAdminResourceDeviceModel";
-declare class APIAdminResource extends APIResource {
-    constructor(parent: object);
-    accessGroups(): APIList;
-    accessGroup(id: number): APIResourceAccessGroup;
-    accounts(): APIList;
-    account(id: number): APIResource;
-    accountServices(): APIList;
-    accountService(id: number): APIAdminResourceAccountService;
-    activities(): APIList;
-    billingPeriods(): APIList;
-    billingPeriod(id: number): APIResource;
-    browsers(): APIList;
-    browser(id: number): APIResource;
-    clusters(): APIList;
-    cluster(id: number): APIAdminResourceCluster;
-    countryVatRates(): APIList;
-    countryVatRate(id: number): APIResource;
-    devices(): APIAdminListDevices;
-    device(id: number): APIAdminResourceDevice;
-    devicesForModel(id: number): APIAdminListDevices;
-    deviceStatuses(): APIList;
-    deviceModels(): APIList;
-    deviceModel(id: number): APIAdminResourceDeviceModel;
-    deviceProblems(): APIList;
-    deviceModelCriterias(): APIList;
-    deviceModelCriteria(id: number): APIResource;
-    deviceSessions(): APIList;
-    deviceSession(id: number): APIAdminResourceDeviceSessionStandalone;
-    deviceTime(): APIAdminResourceDeviceTime;
-    deviceTimeSummary(): APIList;
-    deviceTypes(): APIList;
-    deviceType(id: number): APIResource;
-    deviceGroups(): APIList;
-    deviceGroup(id: number): APIResourceDeviceGroup;
-    emails(): APIList;
-    resendEmail(id: number): APIResource;
-    errors(): APIList;
-    files(): APIList;
-    file(id: number): APIResourceFile;
-    frameworks(): APIList;
-    framework(id: number): APIAdminResourceFramework;
-    frameworkAvailableLabels(): APIList;
-    interactiveQueue(): APIList;
-    licenses(): APIList;
-    license(id: number): APIAdminResourceLicense;
-    maintenance(): APIResource;
-    marketShares(): APIList;
-    notificationPlans(): APIAdminListNotificationPlans;
-    notificationPlan(id: number): APIAdminResourceNotificationPlan;
-    overview(): APIResource;
-    pools(): APIList;
-    pool(id: number): APIResource;
-    projects(): APIList;
-    project(id: number): APIResourceProject;
-    roles(): APIList;
-    runs(): APIAdminListRuns;
-    run(id: number): APIAdminResourceRunStandalone;
-    samples(): APIList;
-    sample(id: number): APIResource;
-    services(): APIAdminListServices;
-    service(id: number): APIAdminResourceService;
-    settings(): APIResource;
-    statistics(): APIAdminListStatistics;
-    users(): APIList;
-    createUser(): APIList;
-    user(id: number): APIAdminResourceUser;
-}
-export default APIAdminResource;
+import { API } from '../API';
+import { APIAdminListDevices } from './APIAdminListDevices';
+import { APIAdminListNotificationPlans } from './APIAdminListNotificationPlans';
+import { APIAdminListRuns } from './APIAdminListRuns';
+import { APIAdminListServices } from './APIAdminListServices';
+import { APIAdminListStatistics } from './APIAdminListStatistics';
+import { APIAdminResourceAccountService } from './APIAdminResourceAccountService';
+import { APIAdminResourceCluster } from './APIAdminResourceCluster';
+import { APIAdminResourceDevice } from './APIAdminResourceDevice';
+import { APIAdminResourceDeviceModel } from './APIAdminResourceDeviceModel';
+import { APIAdminResourceDeviceSessionStandalone } from './APIAdminResourceDeviceSessionStandalone';
+import { APIAdminResourceDeviceTime } from './APIAdminResourceDeviceTime';
+import { APIAdminResourceFramework } from './APIAdminResourceFramework';
+import { APIAdminResourceLicense } from './APIAdminResourceLicense';
+import { APIAdminResourceNotificationPlan } from './APIAdminResourceNotificationPlan';
+import { APIAdminResourceRunStandalone } from './APIAdminResourceRunStandalone';
+import { APIAdminResourceService } from './APIAdminResourceService';
+import { APIAdminResourceUser } from './APIAdminResourceUser';
+import { APIList } from './APIList';
+import { APIResource } from './APIResource';
+import { APIResourceAccessGroup } from './APIResourceAccessGroup';
+import { APIResourceDeviceGroup } from './APIResourceDeviceGroup';
+import { APIResourceFile } from './APIResourceFile';
+import { APIResourceProject } from './APIResourceProject';
+import { AccessGroup, AccessGroupData } from './models/AccessGroup';
+import { Account } from './models/Account';
+import { AccountService } from './models/AccountService';
+import { Activity } from './models/Activity';
+import { AdminDeviceSession, AdminInteractiveDeviceSession } from './models/AdminDeviceSession';
+import { AdminDeviceType, DeviceTypeData } from './models/AdminDeviceType';
+import { AdminEmail } from './models/AdminEmail';
+import { AdminError } from './models/AdminError';
+import { AdminOverview } from './models/AdminOverview';
+import { BillingPeriod } from './models/BillingPeriod';
+import { Browser, BrowserData } from './models/Browser';
+import { CountryVatRate, CountryVatRateData } from './models/CountryVatRate';
+import { DeviceModelCriterion, DeviceModelCriterionData } from './models/DeviceModelCriterion';
+import { DeviceModelPool, DeviceModelPoolData } from './models/DeviceModelPool';
+import { Framework, FrameworkData } from './models/Framework';
+import { License, LicenseData } from './models/License';
+import { Maintenance, MaintenanceData } from './models/Maintenance';
+import { Project } from './models/Project';
+import { Role, RoleParams } from './models/Role';
+import { Settings, SettingsParams } from './models/Settings';
+import { User, UserData, UserParams } from './models/User';
+import { DeviceTimeSummaryParams, UserDeviceTimeSummary } from './models/UserDeviceTimeSummary';
+import { UserFile, UserFileData, UserFileParams } from './models/UserFile';
+import { Cluster } from './models/Cluster';
+import { DeviceProperty } from './models/Device';
+import { DeviceGroup } from './models/DeviceGroup';
+import { DeviceModel } from './models/DeviceModel';
+import { DeviceProblem } from './models/DeviceProblem';
+import { DeviceStatus } from './models/DeviceStatus';
+import { CollectionQueryParams, NoQueryParams } from './models/HTTP';
+export declare class APIAdminResource extends APIResource {
+    constructor(parent: API);
+    accessGroups(): APIList<AccessGroup, CollectionQueryParams, AccessGroupData>;
+    accessGroup(id: number): APIResourceAccessGroup;
+    accounts(): APIList<Account, CollectionQueryParams, any>;
+    account(id: number): APIResource<Account, import("./models/HTTP").QueryParams, import("./models/HTTP").QueryParams>;
+    accountServices(): APIList<AccountService, CollectionQueryParams, any>;
+    accountService(id: number): APIAdminResourceAccountService;
+    activities(): APIList<Activity, CollectionQueryParams, any>;
+    billingPeriods(): APIList<BillingPeriod, CollectionQueryParams, any>;
+    billingPeriod(id: number): APIResource<BillingPeriod, import("./models/HTTP").QueryParams, import("./models/HTTP").QueryParams>;
+    browsers(): APIList<Browser, CollectionQueryParams, BrowserData>;
+    browser(id: number): APIResource<Browser, NoQueryParams, BrowserData>;
+    clusters(): APIList<Cluster, CollectionQueryParams, any>;
+    cluster(id: number): APIAdminResourceCluster;
+    countryVatRates(): APIList<CountryVatRate, CollectionQueryParams, CountryVatRateData>;
+    countryVatRate(id: number): APIResource<CountryVatRate, NoQueryParams, Omit<CountryVatRate, "country">>;
+    devices(): APIAdminListDevices;
+    device(id: number): APIAdminResourceDevice;
+    devicesForModel(id: number): APIAdminListDevices;
+    deviceStatuses(): APIList<DeviceStatus, CollectionQueryParams, any>;
+    deviceModels(): APIList<DeviceModel, CollectionQueryParams, any>;
+    deviceModel(id: number): APIAdminResourceDeviceModel;
+    deviceProblems(): APIList<DeviceProblem, CollectionQueryParams, any>;
+    deviceModelCriterias(): APIList<DeviceModelCriterion, CollectionQueryParams, DeviceModelCriterionData>;
+    deviceModelCriteria(id: number): APIResource<DeviceModelCriterion, import("./models/HTTP").QueryParams, import("./models/HTTP").QueryParams>;
+    deviceSessions(): APIList<AdminDeviceSession, CollectionQueryParams, any>;
+    deviceSession(id: number): APIAdminResourceDeviceSessionStandalone;
+    deviceTime(): APIAdminResourceDeviceTime;
+    deviceTimeSummary(): APIList<UserDeviceTimeSummary, DeviceTimeSummaryParams, any>;
+    deviceTypes(): APIList<AdminDeviceType, CollectionQueryParams, any>;
+    deviceType(id: number): APIResource<AdminDeviceType, NoQueryParams, DeviceTypeData>;
+    deviceGroups(): APIList<DeviceGroup, CollectionQueryParams, any>;
+    deviceGroup(id: number): APIResourceDeviceGroup;
+    emails(): APIList<AdminEmail, CollectionQueryParams, any>;
+    resendEmail(id: number): APIResource<AdminEmail, import("./models/HTTP").QueryParams, import("./models/HTTP").QueryParams>;
+    errors(): APIList<AdminError, CollectionQueryParams, any>;
+    files(): APIList<UserFile, UserFileParams, UserFileData>;
+    file(id: number): APIResourceFile;
+    frameworks<T = Framework, U extends CollectionQueryParams = CollectionQueryParams, W = FrameworkData>(): APIList<T, U, W>;
+    framework(id: number): APIAdminResourceFramework;
+    frameworkAvailableLabels(): APIList<DeviceProperty, CollectionQueryParams, void>;
+    interactiveQueue(): APIList<AdminInteractiveDeviceSession, CollectionQueryParams, any>;
+    licenses(): APIList<License, CollectionQueryParams, LicenseData>;
+    license(id: number): APIAdminResourceLicense;
+    maintenance(): APIResource<Maintenance, NoQueryParams, MaintenanceData>;
+    notificationPlans(): APIAdminListNotificationPlans;
+    notificationPlan(id: number): APIAdminResourceNotificationPlan;
+    overview(): APIResource<AdminOverview, import("./models/HTTP").QueryParams, import("./models/HTTP").QueryParams>;
+    pools(): APIList<DeviceModelPool, CollectionQueryParams, any>;
+    pool(id: number): APIResource<DeviceModelPool, NoQueryParams, DeviceModelPoolData>;
+    projects(): APIList<Project, CollectionQueryParams, any>;
+    project(id: number): APIResourceProject;
+    roles(): APIList<Role, RoleParams, void>;
+    runs(): APIAdminListRuns;
+    run(id: number): APIAdminResourceRunStandalone;
+    samples(): APIList<UserFile, CollectionQueryParams, Pick<UserFileData, "file">>;
+    sample(id: number): APIResource<UserFile, import("./models/HTTP").QueryParams, import("./models/HTTP").QueryParams>;
+    services(): APIAdminListServices;
+    service(id: number): APIAdminResourceService;
+    settings(): APIResource<Settings, SettingsParams, SettingsParams>;
+    statistics(): APIAdminListStatistics;
+    users(): APIList<User, UserParams, UserData>;
+    createUser(): APIList<User, NoQueryParams, UserData>;
+    user(id: number): APIAdminResourceUser;
+}
+export default APIAdminResource;

package/dist/api/APIAdminResourceAccount.d.ts

@@ -1,5 +1,8 @@
-import APIResource from './APIResource';
-declare class APIAdminResourceAccount extends APIResource {
-    constructor(parent: object, id: number);
-}
-export default APIAdminResourceAccount;
+import { APIAdminResource } from './APIAdminResource';
+import { APIResource } from './APIResource';
+import { Account } from './models/Account';
+import { NoData, NoQueryParams } from './models/HTTP';
+export declare class APIAdminResourceAccount extends APIResource<Account, NoQueryParams, NoData> {
+    constructor(parent: APIAdminResource, id: number);
+}
+export default APIAdminResourceAccount;

package/dist/api/APIAdminResourceAccountService.d.ts

@@ -1,7 +1,10 @@
-import APIResource from './APIResource';
-declare class APIAdminResourceAccountService extends APIResource {
-    constructor(parent: object, id: number);
-    activate(): APIResource;
-    deactivate(): APIResource;
-}
-export default APIAdminResourceAccountService;
+import { APIAdminResource } from './APIAdminResource';
+import { APIResource } from './APIResource';
+import { AccountService } from './models/AccountService';
+import { NoData, NoQueryParams } from './models/HTTP';
+export declare class APIAdminResourceAccountService extends APIResource<AccountService, NoQueryParams, NoData> {
+    constructor(parent: APIAdminResource, id: number);
+    activate(): APIResource<AccountService, NoQueryParams, void>;
+    deactivate(): APIResource<AccountService, NoQueryParams, void>;
+}
+export default APIAdminResourceAccountService;

package/dist/api/APIAdminResourceCluster.d.ts

@@ -1,7 +1,11 @@
-import APIResource from './APIResource';
-import APIList from './APIList';
-declare class APIAdminResourceCluster extends APIResource {
-    constructor(parent: object, id: number);
-    devices(): APIList;
-}
-export default APIAdminResourceCluster;
+import { API } from '../API';
+import { APIAdminResource } from './APIAdminResource';
+import { APIList } from './APIList';
+import { APIResource } from './APIResource';
+import { AdminDevice } from './models/AdminDevice';
+import { Cluster, ClusterData, ClusterParams } from './models/Cluster';
+export declare class APIAdminResourceCluster extends APIResource<Cluster, ClusterParams, ClusterData> {
+    constructor(parent: API | APIAdminResource, id: number);
+    devices(): APIList<AdminDevice, import("./models/HTTP").CollectionQueryParams, any>;
+}
+export default APIAdminResourceCluster;