@bitbar/cloud-api-client 0.56.0 → 1.0.0

package/dist/API.d.ts

@@ -1,40 +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";
-import APIResourceBroker from "./api/APIResourceBroker";
-declare class API {
+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;
-    private axiosConfig;
     axios: AxiosInstance;
+    private axiosConfig;
+    get baseUrl(): string;
     constructor(config: ApiConfig);
-    userSession(): APIResourceUserSession;
-    user(id: number | 'me'): APIResourceUser;
-    users(): APIListUsers;
     account(id: number): APIResourceAccount;
-    me(): APIResourceUser;
     admin(): APIAdminResource;
-    devices(): APIListDevices;
+    broker(): APIResourceBroker;
+    clusters(): APIList<Cluster, import("./api/models/HTTP").CollectionQueryParams, any>;
+    cluster(id: number): APIAdminResourceCluster;
     device(id: number): APIResourceDevice;
-    deviceGroups(): APIList;
     deviceGroup(id: number): APIResourceDeviceGroup;
-    deviceSessions(): APIList;
+    deviceGroups(): APIList<any, import("./api/models/HTTP").CollectionQueryParams, any>;
+    devices(): APIListDevices;
     deviceSession(id: number): APIResourceDeviceSession;
-    labelGroups(): APIList;
-    deviceStatistics(): APIList;
-    enums(): APIResource;
-    licenses(): APIResource;
-    labels(): APIList;
-    broker(): APIResourceBroker;
+    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 {
+export declare type ApiConfig = {
     baseURL: string;
-    cloudUrl?: string;
+    cloudUrl: string;
     v2?: boolean;
     apiKey?: string;
     auth?: AxiosBasicCredentials;
     withCredentials?: boolean;
-}
+};
 export default ApiConfig;

package/dist/CloudAPIClient.d.ts

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

package/dist/Filter.d.ts

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

package/dist/FilterBuilder.d.ts

@@ -1,25 +1,24 @@
+import { Filter } from './Filter';
 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;
+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;
+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;
-    desktopBrowserCapabilities(): APIResource;
 }
 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;
+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;
+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;
+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;
+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;
+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(id: number): APIResource;
-    accountServices(): APIList;
+    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;
-    billingPeriods(): APIList;
-    billingPeriod(id: number): APIResource;
-    browsers(): APIList;
-    browser(id: number): APIResource;
-    clusters(): APIList;
+    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(id: number): APIResource;
+    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;
-    deviceModels(): APIList;
+    deviceStatuses(): APIList<DeviceStatus, CollectionQueryParams, any>;
+    deviceModels(): APIList<DeviceModel, CollectionQueryParams, any>;
     deviceModel(id: number): APIAdminResourceDeviceModel;
-    deviceProblems(): APIList;
-    deviceModelCriterias(): APIList;
-    deviceModelCriteria(id: number): APIResource;
-    deviceSessions(): APIList;
+    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;
-    deviceTypes(): APIList;
-    deviceType(id: number): APIResource;
-    deviceGroups(): APIList;
+    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;
-    resendEmail(id: number): APIResource;
-    errors(): APIList;
-    files(): APIList;
+    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(): APIList;
+    frameworks<T = Framework, U extends CollectionQueryParams = CollectionQueryParams, W = FrameworkData>(): APIList<T, U, W>;
     framework(id: number): APIAdminResourceFramework;
-    frameworkAvailableLabels(): APIList;
-    interactiveQueue(): APIList;
-    licenses(): APIList;
+    frameworkAvailableLabels(): APIList<DeviceProperty, CollectionQueryParams, void>;
+    interactiveQueue(): APIList<AdminInteractiveDeviceSession, CollectionQueryParams, any>;
+    licenses(): APIList<License, CollectionQueryParams, LicenseData>;
     license(id: number): APIAdminResourceLicense;
-    maintenance(): APIResource;
-    marketShares(): APIList;
+    maintenance(): APIResource<Maintenance, NoQueryParams, MaintenanceData>;
     notificationPlans(): APIAdminListNotificationPlans;
     notificationPlan(id: number): APIAdminResourceNotificationPlan;
-    overview(): APIResource;
-    pools(): APIList;
-    pool(id: number): APIResource;
-    projects(): APIList;
+    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;
+    roles(): APIList<Role, RoleParams, void>;
     runs(): APIAdminListRuns;
     run(id: number): APIAdminResourceRunStandalone;
-    samples(): APIList;
-    sample(id: number): APIResource;
+    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(): APIResource<Settings, SettingsParams, SettingsParams>;
     statistics(): APIAdminListStatistics;
-    users(): APIList;
-    createUser(): APIList;
+    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);
+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;
+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;
+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;

package/dist/api/APIAdminResourceDevice.d.ts

@@ -1,11 +1,16 @@
-import APIResource from './APIResource';
-import APIList from './APIList';
-declare class APIAdminResourceDevice extends APIResource {
-    constructor(parent: object, id: number);
-    queue(): APIList;
-    cleanupConfiguration(): APIResource;
-    labels(): APIList;
-    label(id: number): APIResource;
-    blink(): APIResource;
+import { APIAdminResource } from './APIAdminResource';
+import { APIList } from './APIList';
+import { APIResource } from './APIResource';
+import { AdminDevice, AdminDeviceData } from './models/AdminDevice';
+import { AdminDeviceSession } from './models/AdminDeviceSession';
+import { DeviceCleanupConfiguration, DeviceCleanupConfigurationData, DeviceLabelData, DeviceProperty } from './models/Device';
+import { NoQueryParams, QueryParams } from './models/HTTP';
+export declare class APIAdminResourceDevice extends APIResource<AdminDevice, NoQueryParams, AdminDeviceData> {
+    constructor(parent: APIAdminResource, id: number);
+    blink(): APIResource<AdminDevice, NoQueryParams, void>;
+    cleanupConfiguration(): APIResource<DeviceCleanupConfiguration, QueryParams, DeviceCleanupConfigurationData>;
+    labels(): APIList<DeviceProperty, NoQueryParams, DeviceLabelData>;
+    label(id: number): APIResource<DeviceProperty, NoQueryParams, void>;
+    queue(): APIList<AdminDeviceSession, import("./models/HTTP").CollectionQueryParams, any>;
 }
 export default APIAdminResourceDevice;

package/dist/api/APIAdminResourceDeviceModel.d.ts

@@ -1,7 +1,11 @@
-import APIResource from './APIResource';
-import APIList from './APIList';
-declare class APIAdminResourceDeviceModel extends APIResource {
-    constructor(parent: object, id: number);
-    browsers(): APIList;
+import { APIAdminResource } from './APIAdminResource';
+import { APIList } from './APIList';
+import { APIResource } from './APIResource';
+import { Browser, DeviceBrowserData } from './models/Browser';
+import { DeviceModel, DeviceModelData } from './models/DeviceModel';
+import { NoQueryParams } from './models/HTTP';
+export declare class APIAdminResourceDeviceModel extends APIResource<DeviceModel, NoQueryParams, DeviceModelData> {
+    constructor(parent: APIAdminResource, id: number);
+    browsers(): APIList<Browser, NoQueryParams, DeviceBrowserData>;
 }
 export default APIAdminResourceDeviceModel;

package/dist/api/APIAdminResourceDeviceSession.d.ts

@@ -1,5 +1,5 @@
-import APIResourceDeviceSessionCommon from './APIResourceDeviceSessionCommon';
-declare class APIAdminResourceDeviceSession extends APIResourceDeviceSessionCommon {
-    changeBillable(billable: boolean): import("./APIResource").default;
+import { APIResourceDeviceSessionCommon } from './APIResourceDeviceSessionCommon';
+export declare class APIAdminResourceDeviceSession extends APIResourceDeviceSessionCommon {
+    changeBillable(billable: boolean): import("./APIResource").APIResource<import("./models/DeviceSession").DeviceSession, import("./models/HTTP").QueryParams, import("./models/HTTP").QueryParams>;
 }
 export default APIAdminResourceDeviceSession;

package/dist/api/APIAdminResourceDeviceSessionStandalone.d.ts

@@ -1,12 +1,6 @@
-import APIResource from './APIResource';
-import APIList from './APIList';
-import APIResourceDeviceSessionCommon from './APIResourceDeviceSessionCommon';
-import DeviceSessionStandalone from './interface/DeviceSessionStandalone';
-import DeviceSessionCommon from './interface/DeviceSessionCommon';
-declare class APIAdminResourceDeviceSessionStandalone extends APIResourceDeviceSessionCommon implements DeviceSessionCommon, DeviceSessionStandalone {
-    changeBillable(billable: boolean): APIResource;
-    connections(): APIList;
-    connection(id: number): APIResource;
-    release(): APIResource;
+import { APIResourceDeviceSessionCommon } from './APIResourceDeviceSessionCommon';
+import { DeviceSessionCommon } from './interface/DeviceSessionCommon';
+export declare class APIAdminResourceDeviceSessionStandalone extends APIResourceDeviceSessionCommon implements DeviceSessionCommon {
+    changeBillable(billable: boolean): import("./APIResource").APIResource<import("./models/DeviceSession").DeviceSession, import("./models/HTTP").QueryParams, import("./models/HTTP").QueryParams>;
 }
 export default APIAdminResourceDeviceSessionStandalone;