@dx-do/client 5.2.48 → 5.2.50

package/dist/src/lib/model/asm/client/types.gen.d.ts

@@ -0,0 +1,4934 @@
+export type ClientOptions = {
+    baseURL: `${string}://${string}/{version}` | (string & {});
+};
+export type ApiTokenNotFound = {
+    status?: string;
+    message?: string;
+};
+export type ApiToken = {
+    id?: number;
+    name?: string;
+    valid_until?: string | null;
+    created?: string;
+};
+export type ContactAuth = {
+    /**
+     * The supported authentication method.
+     */
+    type: "basic" | "bearer";
+    /**
+     * User name if the authentication type requires it
+     */
+    user?: string | null;
+    /**
+     * The authentication secret or token. This value is not sent in GET requests, it can only be created or updated.
+     */
+    secret?: string | null;
+};
+export type ContactCatalogue = {
+    folders: Array<ResourceGroupItemWithPermission>;
+    contacts: Array<ContactItem>;
+};
+export type ContactItem = {
+    id: number;
+    name: string;
+    /**
+     * Group contacts are containers for standard contacts - members.
+     */
+    type: "email" | "sms" | "phone" | "action" | "rss" | "group";
+    /**
+     * Not used for group contact type
+     */
+    address?: string;
+    /**
+     * 0=invalid,1=unconfirmed,2=active,3=blocked,4=inactive
+     */
+    status: 0 | 1 | 2 | 3 | 4;
+    default: boolean;
+    ownerId?: number;
+    folderId?: number | null;
+    /**
+     * Time HH:ss in contact's time zone; workingFrom and workingTo represent time interval when the contact can be alerted.
+     */
+    workingFrom?: string;
+    /**
+     * Time HH:ss in contact's time zone; workingFrom and workingTo represent time interval when the contact can be alerted.
+     */
+    workingTo?: string;
+    /**
+     * Days when the contact can be used for alerting. 0 = Monday ... 6 = Sunday
+     */
+    workingDays?: Array<number>;
+    /**
+     * This time zone is used both for date formating in alert messages
+     * and for the contact's working hours (workingFrom, workingTo). If
+     * empty the time zone of the account is assumed.
+     */
+    timezone?: string | null;
+    /**
+     * For contact groups it contains list of members. For all but contact groups it contains list of groups this contact is member of.
+     */
+    members?: Array<ContactGroupMemberItem>;
+    /**
+     * Authentication details. Authentication can be added for the action url contact type only.
+     */
+    auth?: ContactAuth | {
+        [key: string]: unknown;
+    } | null;
+    /**
+     * Special flags specific for the contact type. Currently, only action contact type supports specifications.
+     * Json changes the content type for the action url to send message as a json instead of standard application/x-www-form-urlencoded.
+     * gchat changes both content type and message form to send message to a Google chat webhook.
+     */
+    specification?: "json" | "gchat";
+};
+export type ContactItemCreate = ContactItemUpdate & {
+    type: "email" | "sms" | "phone" | "action" | "rss" | "group";
+};
+export type ContactItemUpdate = {
+    name?: string | null;
+    /**
+     * Address of the contact. The scheme depends on the contact type.
+     */
+    address?: string | null;
+    /**
+     * Is this contact the default account contact? Only one contact can be default.
+     */
+    default?: boolean | null;
+    /**
+     * ID of the folder this contact should be assigned to
+     */
+    folderId?: number | null;
+    /**
+     * Time HH:ss in contact's time zone; workingFrom and workingTo represent time
+     * interval when the contact can be alerted. Do not use for contact groups.
+     */
+    workingFrom?: string;
+    /**
+     * Time HH:ss in contact's time zone; workingFrom and workingTo represent time
+     * interval when the contact can be alerted. Do not use for contact groups.
+     */
+    workingTo?: string | null;
+    /**
+     * Days when the contact can be alerted. Do not use for contact groups.
+     */
+    workingDays?: Array<number> | null;
+    /**
+     * This time zone is used both for date formating in alert messages and for the
+     * contact's working hours (workingFrom, workingTo). Set the time zone only if
+     * you want another TZ for this particular contact, the time zone of the account
+     * is assumed by default. For updating use null to reset TZ, omit completely to
+     * keep the current value. Do not use for contact groups.
+     */
+    timezone?: string | null;
+    /**
+     * For all contact types but group this parameter must be empty. For contact groups
+     * it is required and must contain list of member contact IDs.
+     */
+    members?: Array<ContactGroupMemberCreate> | null;
+    /**
+     * Authentication details. Authentication can be added for the action url contact type only.
+     */
+    auth?: ContactAuth | {
+        [key: string]: unknown;
+    } | null;
+    /**
+     * Special flags specific for the contact type. Currently, only action contact type supports specifications.
+     * Json changes the content type for the action url to send message as a json instead
+     * of standard application/x-www-form-urlencoded.
+     * gchat changes both content type and message form to send message to a Google chat webhook.
+     */
+    specification?: "json" | "gchat";
+};
+export type ContactGroupMemberItem = {
+    /**
+     * ID of the contact (member of the group)
+     */
+    contactId: number;
+    /**
+     * ID of the group (contact of type group) the contact is member of
+     */
+    groupId: number;
+    /**
+     * Send alert after (alertAfter-1) errors. 0 means alert immediately (after 1 error), 1 after 2 errors, etc.
+     */
+    alertAfter: 0 | 1 | 2 | 3 | 4;
+};
+export type ContactGroupMemberCreate = {
+    /**
+     * ID of the contact (member of the group)
+     */
+    contactId: number;
+    /**
+     * Send alert after (alertAfter-1) errors. 0 means alert immediately (after 1 error), 1 after 2 errors, etc.
+     */
+    alertAfter: 0 | 1 | 2 | 3 | 4;
+};
+export type MaintenanceCatalogue = {
+    folders: Array<ResourceGroupItemWithPermission>;
+    maintenances: Array<MaintenanceItem>;
+};
+export type MaintenanceItem = {
+    id: number;
+    name: string;
+    timezone: string;
+    ruleCount: number;
+    description?: string;
+    persistent?: boolean;
+    windows?: Array<MaintenanceWindowItem>;
+    permission?: PermissionItem;
+    ownerId?: number;
+    folderId?: number | null;
+    monitorIds?: Array<number>;
+    immediateForRuleId?: number | null;
+};
+export type MaintenanceItemCreate = {
+    name?: string;
+    timezone?: string;
+    description?: string;
+    persistent?: boolean;
+    windows?: Array<WindowItemCreate>;
+    folderId?: number | null;
+    monitorIds?: Array<number>;
+};
+export type MaintenanceItemImmediateCreate = {
+    /**
+     * Start of the maintenance window, current time if empty. Format: ISO 8601 date
+     * and time with or without timezone. Current user's timezone is used by default.
+     */
+    from?: string | null;
+    /**
+     * Duration of the immediate maintenance window, format [H][H]H:MM
+     */
+    duration: string;
+    /**
+     * Ids of monitors this maintenance should be assigned to. You need update permission for these monitors
+     */
+    monitorIds: Array<number>;
+};
+export type MaintenanceWindowItem = {
+    id?: number | null;
+    type: "fixed" | "daily" | "weekly" | "monthly";
+    status: "active" | "waiting" | "passed";
+    from: string;
+    to?: string;
+    effectiveTo?: string;
+    /**
+     * For repeating time windows means repeat every N (days, weeks, months).
+     */
+    repeat?: number | null;
+    /**
+     * For weekly recurring time window: 0 - Monday, 6 - Sunday
+     */
+    dow?: Array<number> | null;
+};
+export type WindowItemCreate = {
+    /**
+     * This parameter is always required
+     */
+    type?: "fixed" | "daily" | "weekly" | "montly";
+    /**
+     * This parameter is always required. The time can either be specified without the
+     * time zone or with timezone. In the first case, the maintenance window TZ is used,
+     * in the latter case the time zone is respected but translated to the TZ of the maintenance window.
+     */
+    from?: string;
+    /**
+     * End time of this window applicability. Required for these types: fixed
+     */
+    to?: string;
+    /**
+     * For repeating time windows means repeat every N (days, weeks, months). Required for all but fixed type.
+     */
+    repeat?: number | null;
+    /**
+     * The end time for repeatable time windows. This value is
+     * in the same TZ as the from field (either explicit or inherited from the maintenance
+     * window it belongs to). Required for these types: daily, weekly, monthly.
+     */
+    endTime?: string | null;
+    /**
+     * For weekly recurring time window applicable days: 0 - Monday, 6 - Sunday.
+     */
+    dow?: Array<number> | null;
+};
+export type MessageItem = {
+    id: number;
+    entered: string;
+    sent?: string | null;
+    /**
+     * Monitor ID
+     */
+    monitorId?: number | null;
+    /**
+     * Contact ID
+     */
+    contactId?: number | null;
+    /**
+     * Contact type
+     */
+    type: "email" | "sms" | "phone" | "action" | "rss";
+    /**
+     * Monitor ID
+     */
+    address?: string;
+    /**
+     * Message delivery status
+     */
+    status: "deleted" | "queued" | "gateway" | "provider" | "device" | "accepted" | "queued-no-fallback" | "undeliverable" | "suppressed";
+    /**
+     * Monitor log event uuid
+     */
+    eventId?: string | null;
+    /**
+     * Text of the message
+     */
+    message?: string;
+};
+/**
+ * This schema is used to return a page from the list of monitors with additional pagination information
+ */
+export type MonitorsPage = {
+    /**
+     * List of monitors.
+     */
+    monitors?: Array<Browser | Connect | Dns | Dnsa | Dnsns | Domain | Ftp | Ftps | Http | Https | Imap | Ldap | Ping | Plugin | Pop3 | Scp | Script | Sftp | Sip | Smtp | Telnet | Webdriver>;
+    /**
+     * Number of monitors returned in the monitors array.
+     */
+    numMonitors?: number;
+    /**
+     * Number of unique folders returned the returned monitors belong to. These folders are also attached in the folders array.
+     */
+    numFolders?: number;
+    /**
+     * Number of monitors out of folder in the response
+     */
+    numNotInFolder?: number;
+    /**
+     * Total number of monitors that would be returned if no limit/offset restriction is applied
+     */
+    totalMonitors?: number;
+    /**
+     * Total number of folders that would be returned if no limit/offset restriction is applied
+     */
+    totalFolders?: number;
+    /**
+     * Total number of monitors out of folder if no limit/offset restriction is applied
+     */
+    totalNotInFolder?: number;
+    folders?: FolderItem;
+};
+export type OauthClientCredentialsNotFound = {
+    status?: string;
+    message?: string;
+};
+export type OauthClientCredentialsItem = {
+    id?: number;
+    name?: string;
+    client_id?: string;
+    valid_until?: string | null;
+    access_token_validity?: number | null;
+    refresh_token_validity?: number | null;
+};
+export type OauthToken = {
+    id?: number;
+    /**
+     * Client ID this token is assigned to.
+     */
+    clientId?: number;
+    /**
+     * Date and time when the token expires
+     */
+    expires?: string;
+};
+export type PermissionItem = {
+    type: string;
+    level: string;
+};
+export type ResourceGroupItem = {
+    id?: number;
+    name?: string;
+    ownerId?: number;
+};
+export type ResourceGroupItemWithPermission = ResourceGroupItem & {
+    resourceCount?: number;
+    permission?: PermissionItem;
+};
+export type BulkResponseMetadata = {
+    /**
+     * A bulk response containing multiple sub-responses for bulk operations
+     */
+    success?: number;
+    redirect?: number;
+    client_errors?: number;
+    server_errors?: number;
+};
+export type BulkResponse = {
+    metadata?: BulkResponseMetadata;
+    responses?: Array<BulkResponsePart>;
+};
+/**
+ * One part of a multi-part response
+ *
+ * When performing bulk operations, each item has its own response
+ * This class represents response for one item
+ *
+ * It is merged in BulkResponse
+ */
+export type BulkResponsePart = {
+    /**
+     * ID of the entity this response is connected to (user ID, folder ID...)
+     */
+    id: string | number;
+    /**
+     * This property is renamed in BulkResponse::getCompleteResponse()
+     */
+    status: number;
+    /**
+     * This property is renamed in BulkResponse::getCompleteResponse()
+     */
+    resource?: {
+        [key: string]: unknown;
+    };
+    /**
+     * The subresponse HTTP message
+     */
+    message?: string | null;
+};
+export type FolderItem = FolderRequestItem & {
+    id: number;
+    monitorCount: number;
+    permission?: PermissionItem;
+    specificPermission?: PermissionItem;
+    ownerId?: number;
+};
+export type FolderRequestItem = {
+    name: string;
+    isActive: boolean;
+    notifyOn: boolean;
+};
+export type Forbidden = {
+    status?: string;
+    message?: string;
+};
+export type SettingsItem = {
+    name: string;
+    type?: "bool" | "integer" | "string" | "secret" | "integers";
+    value: string | number | boolean | Array<number>;
+};
+export type StationAgent = {
+    /**
+     * Monitor type
+     */
+    type?: string;
+    /**
+     * Agent name
+     */
+    agent?: string;
+};
+export type StationAgents = {
+    /**
+     * Number of ccagents
+     */
+    ccagent?: number | null;
+    /**
+     * Number of cbot agents
+     */
+    cbot?: number | null;
+    /**
+     * Number of full-page agents
+     */
+    fpm?: number | null;
+    /**
+     * Number of jmeter2 agents
+     */
+    jmeter2?: number | null;
+    /**
+     * Number of jmeter4 agents
+     */
+    jmeter4?: number | null;
+    /**
+     * Number of jmeter5 agents
+     */
+    jmeter5?: number | null;
+    /**
+     * Number of webdriver agents
+     */
+    webdriver?: number | null;
+};
+export type StationItem = {
+    id?: number;
+    /**
+     * The unique host name of this monitoring station
+     */
+    alias?: string;
+    /**
+     * The location ID this station belongs to
+     */
+    locationId?: number;
+    /**
+     * True if the monitoring station is public.
+     */
+    isPublic?: boolean;
+    /**
+     * ID of the monitoring station owner. Public stations have no owners.
+     */
+    ownerId?: number | null;
+    /**
+     * The short code assigned during installation - deprecated
+     */
+    locode?: string;
+    /**
+     * Status of the monitoring station:
+     * 1 - planned, 2 - active, 3 - in maintenance, 4 - blocked,
+     * 5 - installation in progress, 6 = broken - installation failed.
+     */
+    status?: 1 | 2 | 3 | 4 | 5 | 6;
+    /**
+     * The IP address of this monitoring station
+     */
+    host?: string | null;
+    city?: string;
+    latitude?: number;
+    longitude?: number;
+    /**
+     * Weight of the station in the location.
+     */
+    weight?: number;
+    /**
+     * The version of the OS
+     */
+    osVersion?: string;
+    /**
+     * The version of the ASM station installed
+     */
+    version?: string;
+    /**
+     * Custom text description.
+     */
+    description?: string;
+    /**
+     * Engine used for orchestration - kubernetes, docker-composer, etc.
+     */
+    engine?: string;
+    /**
+     * Use ccagent instead of cbot
+     */
+    useCcagent?: boolean;
+};
+export type StationItemCreate = {
+    /**
+     * The host name of this monitoring station
+     */
+    alias?: string;
+    /**
+     * The location ID this station belongs to
+     */
+    locationId?: number;
+    /**
+     * Status of the monitoring station: 1 - planned, 2 - active, 3 - in maintenance, 4 - blocked.
+     */
+    status?: 1 | 2 | 3 | 4;
+    /**
+     * The IP address of this monitoring station
+     */
+    host?: string | null;
+    city?: string;
+    latitude?: number;
+    longitude?: number;
+    /**
+     * Weight of the station in the location.
+     */
+    weight?: number;
+    /**
+     * The version of the OS
+     */
+    osVersion?: string;
+    /**
+     * The version of the ASM station installed
+     */
+    version?: string;
+    /**
+     * This secret is used to encrypt station debug information (status, config, logs). If not provided, the debug information is not available.
+     */
+    secret?: string;
+    /**
+     * Custom text description.
+     */
+    description?: string;
+    /**
+     * Metadata for the installer (json encoded). Internal use only.
+     */
+    installerMetadata?: string;
+    /**
+     * Engine used for orchestration - kubernetes, docker-composer, etc.
+     */
+    engine?: string;
+    /**
+     * Use ccagent instead of cbot
+     */
+    useCcagent?: boolean;
+    agents?: StationAgents | {
+        [key: string]: unknown;
+    } | null;
+};
+export type StationItemDetail = StationItem & {
+    /**
+     * Tunnel ID.
+     */
+    tunnelId?: string;
+    /**
+     * Installation token - it is generated when monitoring station is created or updated or if you request one station details.
+     */
+    token?: string | null;
+    /**
+     * Metadata for the installer (json encoded).
+     */
+    installerMetadata?: string;
+    agents?: StationAgents | {
+        [key: string]: unknown;
+    } | null;
+};
+export type StationLatest = {
+    /**
+     * The current version of the station
+     */
+    version?: string;
+    /**
+     * The current version of the installer
+     */
+    installer?: string;
+};
+export type TimezoneItem = {
+    /**
+     * The name of this timezone
+     */
+    name?: string;
+    /**
+     * [+-]HH:mm offset to UTC
+     */
+    offset?: string;
+    /**
+     * True if the timezone observes/observed DST for the year of the call
+     */
+    hasDst?: boolean;
+    /**
+     * True if the timezone is in DST at the time of the call
+     */
+    isDst?: boolean;
+};
+/**
+ * Class User
+ */
+export type User = UserCreate & {
+    id: number;
+    /**
+     * Date time of last login
+     */
+    lastseen?: string;
+    /**
+     * Status (read only)
+     * 1 ... unconfirmed
+     * 2 ... active
+     * 3 ... blocked
+     * 4 ... unsubscribing
+     * 5 ... on hold
+     */
+    status?: number;
+    /**
+     * List of custom roles the user is member of (read only)
+     */
+    roles?: Array<Role>;
+    /**
+     * Is account locked?
+     */
+    locked?: boolean;
+    /**
+     * True/false if user can login as parent account (owner), null if not evaulated
+     */
+    canLoginAsParent?: boolean | null;
+};
+/**
+ * Class UserCreate
+ */
+export type UserCreate = {
+    email: string;
+    name: string;
+    company?: string;
+    website?: string;
+    address?: string;
+    city?: string;
+    zip?: string;
+    state?: string;
+    /**
+     * ISO 3166-1 alpha-2 country code
+     */
+    country?: string;
+    lang?: string;
+    timezone?: string;
+};
+export type Role = RoleCreate & {
+    /**
+     * Unique role ID
+     */
+    id?: number;
+    /**
+     * Unique role name. Use role ID instead, this value is deprecated.
+     */
+    name: string;
+};
+export type RoleCreate = {
+    description: string;
+};
+/**
+ * Class Location
+ */
+export type Location = LocationDraft & {
+    /**
+     * Unique ID of the location.
+     */
+    id: number;
+    /**
+     * Parent location ID.
+     */
+    parent: number | null;
+    /**
+     * Iso code of the country this location belongs to or null.
+     */
+    country?: string;
+    /**
+     * If true, it is a private (on-premise) location. Otherwise it is a public one.
+     */
+    isPrivate?: boolean;
+    /**
+     * Can the user create nested locations to this location?
+     */
+    canCreateLocations?: boolean;
+    /**
+     * Can the user create private monitoring stations in this location?
+     */
+    canCreateStations?: boolean;
+    /**
+     * Location region details
+     */
+    region?: Region | {
+        [key: string]: unknown;
+    } | null;
+};
+/**
+ * Class LocationDraft
+ */
+export type LocationDraft = {
+    /**
+     * Name of the location.
+     */
+    name: string;
+    /**
+     * Parent location ID or country 2-char iso code.
+     */
+    parent: string;
+    /**
+     * Latitude of the location - position can be used to find the nearest location in scheduler.
+     */
+    latitude?: number;
+    /**
+     * Longitude of the location - position can be used to find the nearest location in scheduler.
+     */
+    longitude?: number;
+    /**
+     * Weight is used to prefer or disfavor this group.
+     */
+    weight?: number;
+};
+/**
+ * Class Region
+ */
+export type Region = {
+    /**
+     * ID of the region.
+     */
+    id?: number;
+    /**
+     * Name of the region.
+     */
+    name?: string | null;
+};
+/**
+ * Add support for certificates to converters
+ */
+export type AllowDenyTrait = {
+    browserRestriction?: "own" | "everywhere" | "custom";
+    /**
+     * Comma-separated whitelisted domains. This will be an array in the future
+     */
+    browserAllow?: string;
+    /**
+     * Comma-separated blacklisted domains. This will be an array in the future
+     */
+    browserDeny?: string;
+};
+export type UseCertificatesTrait = {
+    useClientCert?: boolean;
+    useCaCert?: boolean;
+    certificates?: MonitorCertificates | {
+        [key: string]: unknown;
+    } | null;
+};
+/**
+ * Encryption-settable monitor
+ */
+export type EncryptionTrait = {
+    cipherList?: "ALL" | "HIGH" | "MEDIUM" | "";
+    /**
+     * TODO: "" = negotiate? why nullable then? see in initializeEncryption
+     */
+    encryption?: "tls" | "tlsv1.0" | "tlsv1.1" | "tlsv1.2" | "sslv3" | "";
+};
+/**
+ * Add host:port support to the monitor schema - this may seem odd, but there are URL monitors, host:port monitors and script monitors
+ *
+ * Use in \Cm\Lib\Monitor\Schema\AbstractMonitor and its descendants
+ */
+export type HostPortTrait = {
+    host?: string;
+    port?: number;
+};
+/**
+ * Add IP version selection support to the monitor schema
+ *
+ * Use in \Cm\Lib\Monitor\Schema\AbstractMonitor and its descendants
+ */
+export type IpVersionTrait = {
+    ipVersion?: 0 | 4 | 6;
+};
+/**
+ * Add login support to the monitor schema
+ *
+ * Use in \Cm\Lib\Monitor\Schema\AbstractMonitor and its descendants
+ */
+export type LoginTrait = {
+    username?: string;
+    password?: string;
+};
+/**
+ * Add match string/regex support to the monitor schema
+ *
+ * Use in \Cm\Lib\Monitor\Schema\AbstractMonitor and its descendants
+ */
+export type MatchStringTrait = {
+    matchString?: string;
+};
+/**
+ * Add post data support to the monitor schema
+ *
+ * Use in \Cm\Lib\Monitor\Schema\AbstractMonitor and its descendants
+ */
+export type PostDataTrait = {
+    /**
+     * Enable this option if POST, PUT or PATCH data is in a binary form. This value is disregarded on OPMS before 10.7.
+     */
+    binary?: boolean;
+    /**
+     * Data sent with the PUT, POST and PATCH requests. Binary data must be base64 encoded.
+     */
+    data?: string;
+};
+/**
+ * Add proxy support to the monitor schema
+ */
+export type ProxyTrait = {
+    useProxy?: boolean;
+    /**
+     * The proxy protocol. Not all monitor types can make use of all proxy protocols.
+     * useProxy=true and proxyProtocol=null means 'use system proxy' on OPMS
+     */
+    proxyProtocol?: "http" | "https" | "socks5";
+    proxyAddress?: string | null;
+    proxyPort?: number | null;
+    proxyUsername?: string | null;
+    proxyPassword?: string | null;
+};
+export type RequestHeadersTrait = {
+    requestHeaders?: string;
+};
+export type TransactionPatternsTrait = {
+    transactionPatterns?: string | null;
+};
+/**
+ * Add host:port support to the monitor schema - this may seem odd, but there are URL monitors, host:port monitors and script monitors
+ *
+ * Use in \Cm\Lib\Monitor\Schema\AbstractMonitor and its descendants
+ */
+export type UrlTrait = {
+    url?: string;
+};
+/**
+ * User-Agent-settable monitor
+ */
+export type UserAgentTrait = {
+    /**
+     * Free format user agent to be used with requests, default empty string = native for the agent
+     */
+    userAgent?: string;
+};
+/**
+ * monitor allowing verify certificate setting
+ */
+export type VerifyCertificateTrait = {
+    verifyCertificate?: boolean;
+};
+/**
+ * Common fields present for all monitors
+ */
+export type Monitor = MonitorCreate & {
+    id?: number;
+    /**
+     * Status of the monitor (read only). The status of the folder is not reflected.
+     */
+    status?: "deleted" | "inactive" | "active" | "unconfirmed" | "locked" | "error";
+    /**
+     * Health status of the monitoring station pool (read only). This flag is true if the number of monitoring stations in insufficient.
+     */
+    unhealthy?: boolean | null;
+    /**
+     * Is monitor currently in maintenance mode? (read only)
+     */
+    inMaintenance?: boolean | null;
+};
+/**
+ * Common fields for creating any monitor
+ */
+export type MonitorCreate = MonitorUpdate & {
+    /**
+     * The monitor type.
+     */
+    type: "http" | "https" | "connect" | "dns" | "dnsa" | "dnsns" | "domain" | "ftp" | "ftps" | "imap" | "ldap" | "ping" | "plugin" | "pop3" | "scp" | "sftp" | "sip" | "smtp" | "telnet" | "browser" | "script" | "tls" | "websocket";
+};
+/**
+ * Common updatable fields for all monitors
+ */
+export type MonitorUpdate = {
+    name?: string;
+    /**
+     * The folder id where the monitor will be put. 0 means no folder.
+     */
+    folderId?: number;
+    maintenanceGroupIds?: Array<number>;
+    tagNames?: Array<string>;
+    transactionTag?: string;
+    userNote?: string;
+    /**
+     * This time zone is used for the monitor's run hours (check/periodFrom,
+     * check/periodTo and check/days). If empty the time zone of the owner account is used.
+     */
+    timezone?: string | null;
+    check?: MonitorCheck;
+    alert?: MonitorAlert;
+    checkpoint?: MonitorCheckpoint;
+    /**
+     * Enable this option if monitor should not be scheduled in maintenance.
+     * By default, monitor is scheduled but results are flagged and not used for alerting and SLA calculation.
+     */
+    noScheduleOnMaintenance?: boolean | null;
+    /**
+     * Enable this option if a failing monitor should not be rescheduled.
+     * By default, the monitoring interval is changed to 5 minutes if a monitor starts
+     * failing and the interval is longer than 5 minutes. Once the monitor is OK the
+     * original interval is restored.
+     */
+    noRescheduleOnFailure?: boolean | null;
+};
+/**
+ * Class Alert
+ */
+export type MonitorAlert = {
+    timeWarn?: number;
+    timePoor?: number;
+    timeOut?: number;
+    alertAfter?: -1 | 0 | 1 | 2 | 3 | 4;
+    /**
+     * Currently has no effect
+     */
+    dontDoPostMortem?: boolean;
+    contactId?: number | null;
+    notifyWhenUp?: boolean;
+    quietPeriod?: "00:10:00" | "00:15:00" | "00:20:00" | "00:30:00" | "01:00:00" | "02:00:00" | "03:00:00" | "06:00:00" | "12:00:00" | "18:00:00" | "24:00:00";
+    checkThreshold?: 1 | 2 | 3 | 4 | 5;
+};
+/**
+ * Class Certificate
+ */
+export type MonitorCertificates = {
+    /**
+     * CA certificate or chain for peer verification, either in PKCS12 or PEM format
+     */
+    ca?: string;
+    /**
+     * Client certificate for authentication, either in PKCS12 or PEM format.
+     * Client certificate consists of public (cert) and private (key) parts. Both parts must be included here.
+     */
+    client?: string;
+    clientPassword?: string;
+};
+/**
+ * Class Check
+ */
+export type MonitorCheck = {
+    /**
+     * Scheduler modes - 0(sequential), 1(multi), 4(sequential asynchronous), 5(multi asynchronous). If unsure, use 0
+     */
+    mode?: 0 | 1 | 4 | 5;
+    interval?: string;
+    periodFrom?: string;
+    periodTo?: string;
+    days?: Array<number>;
+};
+/**
+ * Class Checkpoint
+ */
+export type MonitorCheckpoint = {
+    usePublic?: boolean;
+    groupIds?: Array<number> | null;
+    algorithm?: "master" | "random" | "seq" | "sticky";
+    defaultGroupId?: number | null;
+};
+/**
+ * Common FTP/S monitors' fields
+ */
+export type FtpCommonTrait = {
+    path?: string;
+    connectionMode?: 0 | 1 | 2;
+};
+/**
+ * Common HTTP/S monitors' fields
+ */
+export type HttpCommonTrait = UrlTrait & ProxyTrait & LoginTrait & MatchStringTrait & IpVersionTrait & RequestHeadersTrait & UserAgentTrait & PostDataTrait & {
+    /**
+     * HTTP method. If empty, GET (data is empty) or POST (data is not empty) is used. This value is disregarded on OPMS before 10.7.
+     */
+    httpMethod?: "" | "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
+    acceptedHttpCodes?: string;
+    avoidCompression?: boolean;
+    useNtlm?: boolean;
+    redirectLimit?: number;
+};
+export type Browser = ProxyTrait & LoginTrait & MatchStringTrait & RequestHeadersTrait & IpVersionTrait & UserAgentTrait & VerifyCertificateTrait & AllowDenyTrait & TransactionPatternsTrait & Monitor & {
+    url: string;
+    jsErrorReport?: boolean;
+    elemErrorReport?: boolean;
+    toggleQuiescence?: boolean;
+    postVariables?: string;
+};
+export type BrowserCreate = ProxyTrait & LoginTrait & MatchStringTrait & RequestHeadersTrait & IpVersionTrait & UserAgentTrait & VerifyCertificateTrait & AllowDenyTrait & TransactionPatternsTrait & MonitorCreate & {
+    url: string;
+    jsErrorReport?: boolean;
+    elemErrorReport?: boolean;
+    toggleQuiescence?: boolean;
+    postVariables?: string;
+};
+export type BrowserUpdate = ProxyTrait & LoginTrait & MatchStringTrait & RequestHeadersTrait & IpVersionTrait & UserAgentTrait & VerifyCertificateTrait & AllowDenyTrait & TransactionPatternsTrait & MonitorUpdate & {
+    url?: string;
+    jsErrorReport?: boolean;
+    elemErrorReport?: boolean;
+    toggleQuiescence?: boolean;
+    postVariables?: string;
+};
+export type Connect = HostPortTrait & MatchStringTrait & Monitor;
+export type ConnectCreate = HostPortTrait & MatchStringTrait & MonitorCreate;
+export type ConnectUpdate = HostPortTrait & MatchStringTrait & MonitorUpdate;
+/**
+ * Class Dns
+ */
+export type Dns = Monitor & {
+    domainName: string;
+    port: number;
+    recordType?: "A" | "AAAA" | "MX" | "NS" | "CNAME" | "PTR" | "SOA" | "TXT";
+    /**
+     * Comma-separated expected RR values. This will be an array in the future
+     */
+    expectedResult?: string;
+    retries?: 0 | 1 | 2 | 3;
+    match?: -1 | 0 | 1;
+    protocol?: "tcp" | "udp";
+    target?: string;
+    respondThreshold?: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    delimiter?: "" | "," | "|" | ";" | "#|#" | "#;#" | "#ASM_ITEM_DELIMITER#";
+};
+/**
+ * Class Dns
+ */
+export type DnsCreate = MonitorCreate & {
+    domainName: string;
+    port: number;
+    recordType?: "A" | "AAAA" | "MX" | "NS" | "CNAME" | "PTR" | "SOA" | "TXT";
+    /**
+     * Comma-separated expected RR values. This will be an array in the future
+     */
+    expectedResult?: string;
+    retries?: 0 | 1 | 2 | 3;
+    match?: -1 | 0 | 1;
+    protocol?: "tcp" | "udp";
+    target?: string;
+    respondThreshold?: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    delimiter?: "" | "," | "|" | ";" | "#|#" | "#;#" | "#ASM_ITEM_DELIMITER#";
+};
+/**
+ * Class Monitor
+ */
+export type DnsUpdate = MonitorUpdate & {
+    domainName?: string;
+    port?: number;
+    recordType?: "A" | "AAAA" | "MX" | "NS" | "CNAME" | "PTR" | "SOA" | "TXT";
+    /**
+     * Comma-separated expected RR values. This will be an array in the future
+     */
+    expectedResult?: string;
+    retries?: 0 | 1 | 2 | 3;
+    match?: -1 | 0 | 1;
+    protocol?: "tcp" | "udp";
+    target?: string;
+    respondThreshold?: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    delimiter?: "" | "," | "|" | ";" | "#|#" | "#;#" | "#ASM_ITEM_DELIMITER#";
+};
+export type Dnsa = HostPortTrait & Monitor & {
+    path: string;
+    maxQueries: number;
+};
+export type DnsaCreate = HostPortTrait & MonitorCreate & {
+    path: string;
+    maxQueries: number;
+};
+export type DnsaUpdate = HostPortTrait & MonitorUpdate & {
+    path?: string;
+    maxQueries?: number;
+};
+export type Dnsns = HostPortTrait & Monitor & {
+    path: string;
+    maxQueries: number;
+};
+export type DnsnsCreate = HostPortTrait & MonitorCreate & {
+    path: string;
+    maxQueries: number;
+};
+export type DnsnsUpdate = HostPortTrait & MonitorUpdate & {
+    path?: string;
+    maxQueries?: number;
+};
+/**
+ * Class Domain
+ */
+export type Domain = Monitor & {
+    domainName: string;
+    port: number;
+    retries: 0 | 1 | 2 | 3;
+    protocol: "tcp" | "udp";
+    target: string;
+    respondThreshold: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    doZoneTransfer?: boolean;
+};
+/**
+ * Class Domain
+ */
+export type DomainCreate = MonitorCreate & {
+    domainName: string;
+    port: number;
+    retries: 0 | 1 | 2 | 3;
+    protocol: "tcp" | "udp";
+    target: string;
+    respondThreshold: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    doZoneTransfer?: boolean;
+};
+/**
+ * Class Monitor
+ */
+export type DomainUpdate = MonitorUpdate & {
+    domainName?: string;
+    port?: number;
+    retries?: 0 | 1 | 2 | 3;
+    protocol?: "tcp" | "udp";
+    target?: string;
+    respondThreshold?: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    doZoneTransfer?: boolean;
+};
+/**
+ * FTP monitor
+ */
+export type Ftp = FtpCommonTrait & HostPortTrait & MatchStringTrait & LoginTrait & IpVersionTrait & Monitor;
+export type FtpCreate = FtpCommonTrait & HostPortTrait & MatchStringTrait & LoginTrait & IpVersionTrait & MonitorCreate;
+export type FtpUpdate = FtpCommonTrait & HostPortTrait & MatchStringTrait & LoginTrait & IpVersionTrait & MonitorUpdate;
+export type Ftps = FtpCommonTrait & HostPortTrait & MatchStringTrait & LoginTrait & IpVersionTrait & Monitor;
+export type FtpsCreate = FtpCommonTrait & HostPortTrait & MatchStringTrait & LoginTrait & IpVersionTrait & MonitorCreate;
+export type FtpsUpdate = FtpCommonTrait & HostPortTrait & MatchStringTrait & LoginTrait & IpVersionTrait & MonitorUpdate;
+/**
+ * The definition of HTTP monitor type
+ */
+export type Http = HttpCommonTrait & Monitor;
+export type HttpCreate = HttpCommonTrait & MonitorCreate;
+export type HttpUpdate = HttpCommonTrait & MonitorUpdate;
+export type Https = HttpCommonTrait & UseCertificatesTrait & EncryptionTrait & VerifyCertificateTrait & Http;
+export type HttpsCreate = HttpCommonTrait & UseCertificatesTrait & EncryptionTrait & VerifyCertificateTrait & MonitorCreate;
+export type HttpsUpdate = HttpCommonTrait & UseCertificatesTrait & EncryptionTrait & VerifyCertificateTrait & MonitorUpdate;
+export type Imap = HostPortTrait & LoginTrait & VerifyCertificateTrait & Monitor & {
+    path?: string;
+    sslEncryption?: boolean;
+    emailAddress?: string;
+};
+export type ImapCreate = HostPortTrait & LoginTrait & VerifyCertificateTrait & MonitorCreate & {
+    path?: string;
+    sslEncryption?: boolean;
+    emailAddress?: string;
+};
+export type ImapUpdate = HostPortTrait & LoginTrait & VerifyCertificateTrait & MonitorUpdate & {
+    path?: string;
+    sslEncryption?: boolean;
+    emailAddress?: string;
+};
+export type Ldap = HostPortTrait & LoginTrait & MatchStringTrait & IpVersionTrait & VerifyCertificateTrait & Monitor & {
+    /**
+     * The search base and filter. Spaces in the filter must be replaced with %20
+     */
+    path?: string;
+    sslEncryption?: boolean;
+};
+export type LdapCreate = HostPortTrait & LoginTrait & MatchStringTrait & IpVersionTrait & VerifyCertificateTrait & MonitorCreate & {
+    /**
+     * The search base and filter. Spaces in the filter must be replaced with %20
+     */
+    path?: string;
+    sslEncryption?: boolean;
+};
+export type LdapUpdate = HostPortTrait & LoginTrait & MatchStringTrait & IpVersionTrait & VerifyCertificateTrait & MonitorUpdate & {
+    /**
+     * The search base and filter. Spaces in the filter must be replaced with %20
+     */
+    path?: string;
+    sslEncryption?: boolean;
+};
+export type Ping = IpVersionTrait & Monitor & {
+    host: string;
+    /**
+     * Packet loss in % (1-100)
+     */
+    packetLossThreshold: number;
+};
+export type PingCreate = IpVersionTrait & MonitorCreate & {
+    host: string;
+    /**
+     * Packet loss in % (1-100)
+     */
+    packetLossThreshold: number;
+};
+export type PingUpdate = IpVersionTrait & MonitorUpdate & {
+    host?: string;
+    /**
+     * Packet loss in % (1-100)
+     */
+    packetLossThreshold?: number;
+};
+export type Plugin = UrlTrait & LoginTrait & Monitor & {
+    parameters?: string;
+};
+export type PluginCreate = UrlTrait & LoginTrait & MonitorCreate & {
+    parameters?: string;
+};
+export type PluginUpdate = UrlTrait & LoginTrait & MonitorUpdate & {
+    parameters?: string;
+};
+export type Pop3 = HostPortTrait & LoginTrait & VerifyCertificateTrait & Monitor & {
+    sslEncryption?: boolean;
+    emailAddress?: string;
+};
+export type Pop3Create = HostPortTrait & LoginTrait & VerifyCertificateTrait & MonitorCreate & {
+    sslEncryption?: boolean;
+    emailAddress?: string;
+};
+export type Pop3Update = HostPortTrait & LoginTrait & VerifyCertificateTrait & MonitorUpdate & {
+    sslEncryption?: boolean;
+    emailAddress?: string;
+};
+export type Scp = HostPortTrait & LoginTrait & MatchStringTrait & IpVersionTrait & Monitor & {
+    path?: string;
+};
+export type ScpCreate = HostPortTrait & LoginTrait & MatchStringTrait & IpVersionTrait & MonitorCreate & {
+    path?: string;
+};
+export type ScpUpdate = HostPortTrait & LoginTrait & MatchStringTrait & IpVersionTrait & MonitorUpdate & {
+    path?: string;
+};
+export type Script = UseCertificatesTrait & ProxyTrait & LoginTrait & Monitor & {
+    host: string;
+    port: number;
+    path?: string;
+    encryption?: "tls" | "tlsv1.0" | "tlsv1.1" | "tlsv1.2" | "sslv3";
+    assertOnly?: boolean;
+    responseContent?: boolean;
+    scriptFile?: MonitorScript;
+};
+export type ScriptCreate = UseCertificatesTrait & ProxyTrait & LoginTrait & MonitorCreate & {
+    host?: string;
+    port?: number;
+    path?: string;
+    encryption?: "tls" | "tlsv1.0" | "tlsv1.1" | "tlsv1.2" | "sslv3";
+    assertOnly?: boolean;
+    responseContent?: boolean;
+    scriptFile?: MonitorScriptCreate | {
+        [key: string]: unknown;
+    } | null;
+};
+export type ScriptUpdate = UseCertificatesTrait & ProxyTrait & LoginTrait & MonitorUpdate & {
+    host?: string;
+    port?: number;
+    path?: string;
+    encryption?: "tls" | "tlsv1.0" | "tlsv1.1" | "tlsv1.2" | "sslv3";
+    assertOnly?: boolean;
+    responseContent?: boolean;
+    scriptFile?: MonitorScriptCreate | {
+        [key: string]: unknown;
+    } | null;
+};
+export type Sftp = HostPortTrait & LoginTrait & MatchStringTrait & IpVersionTrait & Monitor & {
+    path?: string;
+};
+export type SftpCreate = HostPortTrait & LoginTrait & MatchStringTrait & IpVersionTrait & MonitorCreate & {
+    path?: string;
+};
+export type SftpUpdate = HostPortTrait & LoginTrait & MatchStringTrait & IpVersionTrait & MonitorUpdate & {
+    path?: string;
+};
+export type Sip = HostPortTrait & Monitor;
+export type SipCreate = HostPortTrait & MonitorCreate;
+export type SipUpdate = HostPortTrait & MonitorUpdate;
+export type Smtp = HostPortTrait & Monitor;
+export type SmtpCreate = HostPortTrait & MonitorCreate;
+export type SmtpUpdate = HostPortTrait & MonitorUpdate;
+export type Telnet = HostPortTrait & Monitor;
+export type TelnetCreate = HostPortTrait & MonitorCreate;
+export type TelnetUpdate = HostPortTrait & MonitorUpdate;
+/**
+ * TLS monitor for server certificate monitoring
+ */
+export type Tls = HostPortTrait & UseCertificatesTrait & ProxyTrait & IpVersionTrait & EncryptionTrait & Monitor & {
+    expirationShift?: number;
+};
+export type TlsCreate = HostPortTrait & UseCertificatesTrait & ProxyTrait & IpVersionTrait & EncryptionTrait & MonitorCreate & {
+    expirationShift?: number;
+};
+export type TlsUpdate = HostPortTrait & UseCertificatesTrait & ProxyTrait & IpVersionTrait & EncryptionTrait & MonitorUpdate & {
+    expirationShift?: number;
+};
+export type Webdriver = ProxyTrait & UseCertificatesTrait & LoginTrait & UserAgentTrait & VerifyCertificateTrait & AllowDenyTrait & TransactionPatternsTrait & Monitor & {
+    host?: string;
+    elemErrorReport?: boolean;
+    toggleQuiescence?: boolean;
+    /**
+     * Enable this option if monitor is monitoring page leveraging additionaly the browser
+     * agent and webdriver is expected to wait for the browser agent to send the metrics
+     * before executing the next step. Do not enable it unless you know what you are doing.
+     * If browser is NOT present and this value is enabled, monitor will timeout on the first
+     * step waiting for browser agent confirmation.
+     */
+    browserAgent?: boolean | null;
+    proxyExcludeHosts?: string;
+    /**
+     * Comma-separated, colon-separated domain pairs. This will be an array in the future
+     */
+    remapHosts?: string;
+    blockHtml5Media?: boolean;
+    browser?: string;
+    authenticationType?: string;
+    scriptFile?: MonitorScript;
+};
+export type WebdriverCreate = ProxyTrait & UseCertificatesTrait & LoginTrait & UserAgentTrait & VerifyCertificateTrait & AllowDenyTrait & TransactionPatternsTrait & MonitorCreate & {
+    host?: string;
+    elemErrorReport?: boolean;
+    toggleQuiescence?: boolean;
+    /**
+     * Enable this option if monitor is monitoring page leveraging additionaly
+     * the browser agent and webdriver is expected to wait for the browser agent
+     * to send the metrics before executing the next step. Do not enable it unless
+     * you know what you are doing. If browser is NOT present and this value is enabled,
+     * monitor will timeout on the first step waiting for browser agent confirmation.
+     */
+    browserAgent?: boolean | null;
+    proxyExcludeHosts?: string;
+    /**
+     * Comma-separated, colon-separated domain pairs. This will be an array in the future
+     */
+    remapHosts?: string;
+    blockHtml5Media?: boolean;
+    browser?: string;
+    authenticationType?: string;
+    scriptFile?: MonitorScriptCreate | {
+        [key: string]: unknown;
+    } | null;
+};
+export type WebdriverUpdate = ProxyTrait & UseCertificatesTrait & LoginTrait & UserAgentTrait & VerifyCertificateTrait & AllowDenyTrait & TransactionPatternsTrait & MonitorUpdate & {
+    host?: string;
+    elemErrorReport?: boolean;
+    toggleQuiescence?: boolean;
+    /**
+     * Enable this option if monitor is monitoring page leveraging additionaly the
+     * browser agent and webdriver is expected to wait for the browser agent to send
+     * the metrics before executing the next step. Do not enable it unless you know
+     * what you are doing. If browser is NOT present and this value is enabled, monitor
+     * will timeout on the first step waiting for browser agent confirmation.
+     */
+    browserAgent?: boolean | null;
+    proxyExcludeHosts?: string;
+    /**
+     * Comma-separated, colon-separated domain pairs. This will be an array in the future
+     */
+    remapHosts?: string;
+    blockHtml5Media?: boolean;
+    browser?: string;
+    authenticationType?: string;
+    scriptFile?: MonitorScriptCreate | {
+        [key: string]: unknown;
+    } | null;
+};
+export type Websocket = UrlTrait & ProxyTrait & UseCertificatesTrait & VerifyCertificateTrait & LoginTrait & MatchStringTrait & IpVersionTrait & PostDataTrait & RequestHeadersTrait & UserAgentTrait & Monitor & {
+    healthCheck?: boolean;
+    idleDelay?: number;
+};
+export type WebsocketCreate = UrlTrait & ProxyTrait & UseCertificatesTrait & VerifyCertificateTrait & LoginTrait & MatchStringTrait & IpVersionTrait & PostDataTrait & RequestHeadersTrait & UserAgentTrait & MonitorCreate & {
+    healthCheck?: boolean;
+    idleDelay?: number;
+};
+export type WebsocketUpdate = UrlTrait & ProxyTrait & UseCertificatesTrait & VerifyCertificateTrait & LoginTrait & MatchStringTrait & IpVersionTrait & PostDataTrait & RequestHeadersTrait & UserAgentTrait & MonitorUpdate & {
+    healthCheck?: boolean;
+    idleDelay?: number;
+};
+/**
+ * Class MonitorFrame
+ * This schema is used in the APIv3 to get list of monitors when the performance matters.
+ * To retrieve full list of monitor properties lots of per-monitor queries must be executed which is time consuming (e.g. maintenance status).
+ * This schema contains only parameters that needs no extra queries and/or lengthy calculations.
+ * These parameters should be sufficient to get list of monitors for charts, selection dropboxes etc.
+ */
+export type MonitorFrame = {
+    id?: number;
+    /**
+     * The monitor type.
+     */
+    type?: "http" | "https" | "connect" | "dns" | "dnsa" | "dnsns" | "domain" | "ftp" | "ftps" | "imap" | "ldap" | "ping" | "plugin" | "pop3" | "scp" | "sftp" | "sip" | "smtp" | "telnet" | "browser" | "script";
+    name?: string;
+    folderId?: number;
+    /**
+     * Status of the monitor (read only). The status of the folder is not reflected.
+     */
+    status?: "deleted" | "inactive" | "active" | "unconfirmed" | "locked" | "error";
+    /**
+     * Health status of the monitoring station pool (read only). This flag is true if the number of monitoring stations in insufficient.
+     */
+    unhealthy?: boolean | null;
+};
+/**
+ * Class ScriptFile
+ */
+export type MonitorScript = MonitorScriptCreate & {
+    /**
+     * ID of the script
+     */
+    scriptId?: number;
+    content?: string | null;
+};
+/**
+ * Class ScriptFileCreate
+ */
+export type MonitorScriptCreate = {
+    /**
+     * If you want to reuse a previously uploaded script, send this ID
+     * but not the new script content. This feature is deprecated, will
+     * be removed in the future releases without notice.
+     */
+    scriptId?: number | null;
+    contentArchive?: string | null;
+    parameters?: string | null;
+    stages?: string | null;
+};
+export type MonitorTag = {
+    id?: number;
+    name?: string;
+};
+export type EventAsset = {
+    url?: string;
+    type?: "jtl" | "har" | "http" | "image" | "video" | "log" | "console_log";
+};
+export type LogEvent = {
+    id?: string;
+    monitor?: StatisticResource;
+    location?: StatisticResource;
+    folder?: StatisticResource;
+    start?: string;
+    duration?: number;
+    interval?: number;
+    monitor_type?: string;
+    result?: EventResult;
+    metrics?: LogEventMetrics;
+    assets?: Array<EventAsset> | null;
+    probeMetrics?: ProbeMetrics | {
+        [key: string]: unknown;
+    } | null;
+};
+export type LogEventMetrics = {
+    /**
+     * Resolve time (ms)
+     */
+    rtime?: number;
+    /**
+     * Connect time (ms)
+     */
+    ctime?: number;
+    /**
+     * First byte time (ms)
+     */
+    ptime?: number;
+    /**
+     * Download time (ms)
+     */
+    dtime?: number;
+    /**
+     * User interaction time (ms)
+     */
+    utime?: number;
+    /**
+     * Download size (bytes)
+     */
+    dsize?: number;
+    /**
+     * Number of multi-check probes performed, including internal errors
+     */
+    multi_probes_all?: number;
+    /**
+     * Number of multi-check probes performed, excluding internal errors
+     */
+    multi_probes?: number;
+    /**
+     * Number of multi-check probes failed, excluding internal errors
+     */
+    multi_probes_failed?: number;
+};
+export type MetricResource = {
+    probes?: number;
+    probe_ok?: number;
+    probe_errors?: number;
+    checks?: number;
+    check_errors?: number;
+    checks_maint?: number;
+    maint_errors?: number;
+    rtime?: number;
+    ctime?: number;
+    ptime?: number;
+    utime?: number;
+    dtime?: number;
+    rtime_ok?: number;
+    ctime_ok?: number;
+    ptime_ok?: number;
+    utime_ok?: number;
+    dtime_ok?: number;
+    dsize?: number;
+    dev_rtime?: number;
+    dev_ctime?: number;
+    dev_ptime?: number;
+    dev_utime?: number;
+    dev_dtime?: number;
+    dev_dsize?: number;
+    xtime?: number;
+    xtime_ok?: number;
+    xspeed?: number;
+    upstatus?: number;
+    perfstatus?: number;
+    score?: number;
+    spi_score?: number;
+    spi_penalty?: number;
+    uptime?: number;
+    downtime?: number;
+    ttime?: number;
+    ttime_ok?: number;
+    dspeed?: number;
+    slawarn?: number;
+    slapoor?: number;
+    apdex?: number;
+};
+export type ProbeMetrics = {
+    id?: string;
+    startTime?: string;
+    duration?: number;
+    failed?: boolean | null;
+    statusCode?: number | null;
+    statusString?: string | null;
+    domain?: string | null;
+    performance?: "good" | "poor" | "bad";
+    metrics?: StageMetrics;
+    stages?: Array<Stage>;
+};
+export type EventResult = {
+    code?: number;
+    description?: string;
+    type?: "ok" | "unconfirmed_error" | "confirmed_error" | "maintenance" | "unscheduled";
+    /**
+     * For successful checks this value is calculated based on total time and monitor thresholds
+     */
+    performance?: "good" | "poor" | "bad";
+};
+export type Stage = {
+    name?: string;
+    startTime?: string;
+    duration?: number;
+    failed?: boolean | null;
+    statusCode?: number | null;
+    statusString?: string | null;
+    CorID?: string | null;
+    metrics?: StageMetrics;
+    transactions?: Array<Transaction>;
+};
+export type StageMetrics = {
+    /**
+     * Time spent in HTTP client's queue before starting the request (ms)
+     */
+    blocked?: number | null;
+    /**
+     * Time spent on the TLS handshake (ms)
+     */
+    tls?: number | null;
+    /**
+     * Time spent on resolution of the IP address from the URI (ms)
+     */
+    dns?: number | null;
+    /**
+     * Time spent on establishing connection to the monitored service (ms)
+     */
+    connect?: number | null;
+    /**
+     * Time spent on sending request (ms)
+     */
+    upload?: number | null;
+    /**
+     * Time since upload was completed until the server starts sending response (ms)
+     */
+    firstByte?: number | null;
+    /**
+     * Time spent on receiving response (ms)
+     */
+    download?: number | null;
+    /**
+     * Size of request, including headers (bytes)
+     */
+    uploadSize?: number | null;
+    /**
+     * Size of response, including headers (bytes)
+     */
+    downloadSize?: number | null;
+    /**
+     * Size of request headers (bytes)
+     */
+    uploadHeadersSize?: number | null;
+    /**
+     * Size of response headers (bytes)
+     */
+    downloadHeadersSize?: number | null;
+    /**
+     * Time since start of the stage until the onContentLoad event (ms)
+     */
+    onContentLoad?: number | null;
+    /**
+     * Time since start of the stage until the onLoad event (ms)
+     */
+    onLoad?: number | null;
+    /**
+     * Number of transactions in this stage
+     */
+    requestCount?: number | null;
+    /**
+     * Number of failed transactions
+     */
+    failedCount?: number | null;
+    /**
+     * Time spent executing transactions (ms)
+     */
+    totalTime?: number | null;
+    /**
+     * Number of HTTP redirects
+     */
+    redirectCount?: number | null;
+    /**
+     * Total time spent on HTTP redirects
+     */
+    redirectTime?: number | null;
+};
+export type StatisticItem = {
+    timestamp: string;
+    monitors: Array<StatisticResource>;
+    locations: Array<StatisticResource>;
+    metrics?: MetricResource;
+};
+export type StatisticResource = {
+    id: number;
+    name: string;
+};
+export type Transaction = {
+    /**
+     * URI of the monitored service
+     */
+    uri?: string;
+    /**
+     * IP address of the monitored service
+     */
+    serverIp?: string;
+    startTime?: string;
+    duration?: number;
+    failed?: boolean | null;
+    statusCode?: number | null;
+    statusString?: string | null;
+    metrics?: TransactionMetrics;
+};
+export type TransactionMetrics = {
+    /**
+     * Time spent in HTTP client's queue before starting the request (ms)
+     */
+    blocked?: number | null;
+    /**
+     * Time spent on the TLS handshake (ms)
+     */
+    tls?: number | null;
+    /**
+     * Time spent on resolution of the IP address from the URI (ms)
+     */
+    dns?: number | null;
+    /**
+     * Time spent on establishing connection to the monitored service (ms)
+     */
+    connect?: number | null;
+    /**
+     * Time spent on sending request (ms)
+     */
+    upload?: number | null;
+    /**
+     * Time since upload was completed until the server starts sending response (ms)
+     */
+    firstByte?: number | null;
+    /**
+     * Time spent on receiving response (ms)
+     */
+    download?: number | null;
+    /**
+     * Size of request, including headers (bytes)
+     */
+    uploadSize?: number | null;
+    /**
+     * Size of response, including headers (bytes)
+     */
+    downloadSize?: number | null;
+    /**
+     * Size of request headers (bytes)
+     */
+    uploadHeadersSize?: number | null;
+    /**
+     * Size of response headers (bytes)
+     */
+    downloadHeadersSize?: number | null;
+};
+export type ApiTokenListData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/api-token";
+};
+export type ApiTokenListErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type ApiTokenListError = ApiTokenListErrors[keyof ApiTokenListErrors];
+export type ApiTokenListResponses = {
+    /**
+     * Success
+     */
+    200: Array<ApiToken>;
+};
+export type ApiTokenListResponse = ApiTokenListResponses[keyof ApiTokenListResponses];
+export type ApiTokenCreateData = {
+    body: {
+        name?: string;
+        valid_until?: string;
+    };
+    path?: never;
+    query?: never;
+    url: "/api-token";
+};
+export type ApiTokenCreateErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type ApiTokenCreateError = ApiTokenCreateErrors[keyof ApiTokenCreateErrors];
+export type ApiTokenCreateResponses = {
+    /**
+     * Success
+     */
+    201: {
+        status?: string;
+        data?: {
+            id?: number;
+            name?: string;
+            token?: string;
+            valid_until?: string;
+        };
+    };
+};
+export type ApiTokenCreateResponse = ApiTokenCreateResponses[keyof ApiTokenCreateResponses];
+export type ApiTokenDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * The ID of the token to delete
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/api-token/{id}";
+};
+export type ApiTokenDeleteErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Token not found
+     */
+    404: ApiTokenNotFound;
+};
+export type ApiTokenDeleteError = ApiTokenDeleteErrors[keyof ApiTokenDeleteErrors];
+export type ApiTokenDeleteResponses = {
+    /**
+     * Success
+     */
+    200: {
+        message?: string;
+    };
+};
+export type ApiTokenDeleteResponse = ApiTokenDeleteResponses[keyof ApiTokenDeleteResponses];
+export type ApiTokenGetData = {
+    body?: never;
+    path: {
+        /**
+         * Token ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/api-token/{id}";
+};
+export type ApiTokenGetErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Token not found
+     */
+    404: ApiTokenNotFound;
+};
+export type ApiTokenGetError = ApiTokenGetErrors[keyof ApiTokenGetErrors];
+export type ApiTokenGetResponses = {
+    /**
+     * Success
+     */
+    200: ApiToken;
+};
+export type ApiTokenGetResponse = ApiTokenGetResponses[keyof ApiTokenGetResponses];
+export type ApiTokenUpdateData = {
+    /**
+     * The request body for updating token. Name is mandatory, valid_until is
+     * optional and defaults to null (valid indefinitely), can be any valid datetime string.
+     */
+    body: {
+        name?: string;
+        valid_until?: string;
+    };
+    path: {
+        /**
+         * The ID of the item to update
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/api-token/{id}";
+};
+export type ApiTokenUpdateErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Token not found
+     */
+    404: ApiTokenNotFound;
+};
+export type ApiTokenUpdateError = ApiTokenUpdateErrors[keyof ApiTokenUpdateErrors];
+export type ApiTokenUpdateResponses = {
+    /**
+     * Success
+     */
+    200: {
+        message?: string;
+        data?: ApiToken;
+    };
+};
+export type ApiTokenUpdateResponse = ApiTokenUpdateResponses[keyof ApiTokenUpdateResponses];
+export type CheckGetData = {
+    body?: never;
+    path: {
+        /**
+         * Monitor ID.
+         */
+        monitor: string;
+    };
+    query?: never;
+    url: "/check/{monitor}";
+};
+export type CheckGetErrors = {
+    /**
+     * No subscription available to run this monitor.
+     */
+    402: {
+        message?: string;
+    };
+    /**
+     * Access to the monitor denied.
+     */
+    403: {
+        message?: string;
+    };
+    /**
+     * Monitor not found.
+     */
+    404: {
+        message?: string;
+    };
+    /**
+     * Check executed too soon, try again later
+     */
+    429: {
+        message?: string;
+    };
+    /**
+     * Other error
+     */
+    500: {
+        message?: string;
+    };
+    /**
+     * Temporary error, try again later
+     */
+    503: {
+        message?: string;
+    };
+};
+export type CheckGetError = CheckGetErrors[keyof CheckGetErrors];
+export type CheckGetResponses = {
+    /**
+     * Success
+     */
+    200: LogEvent;
+};
+export type CheckGetResponse = CheckGetResponses[keyof CheckGetResponses];
+export type ContactsGetData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/contacts";
+};
+export type ContactsGetErrors = {
+    /**
+     * Access to the resource was denied.
+     */
+    403: {
+        message?: string;
+    };
+};
+export type ContactsGetError = ContactsGetErrors[keyof ContactsGetErrors];
+export type ContactsGetResponses = {
+    /**
+     * Success
+     */
+    200: ContactCatalogue;
+};
+export type ContactsGetResponse = ContactsGetResponses[keyof ContactsGetResponses];
+export type ContactsCreateData = {
+    body?: ContactItemCreate;
+    path?: never;
+    query?: never;
+    url: "/contacts";
+};
+export type ContactsCreateErrors = {
+    /**
+     * Unsupported contact type
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * You don't have permission to create a contact in this folder
+     */
+    403: {
+        message?: string;
+    };
+};
+export type ContactsCreateError = ContactsCreateErrors[keyof ContactsCreateErrors];
+export type ContactsCreateResponses = {
+    /**
+     * Success
+     */
+    201: ContactItem;
+};
+export type ContactsCreateResponse = ContactsCreateResponses[keyof ContactsCreateResponses];
+export type ContactDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Contact id
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/contacts/{id}";
+};
+export type ContactDeleteErrors = {
+    /**
+     * The channel is used for alerting.
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Access to the contact was denied.
+     */
+    403: {
+        message?: string;
+    };
+    /**
+     * Contact not found or or insufficient privileges
+     */
+    404: {
+        message?: string;
+    };
+};
+export type ContactDeleteError = ContactDeleteErrors[keyof ContactDeleteErrors];
+export type ContactDeleteResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type ContactDeleteResponse = ContactDeleteResponses[keyof ContactDeleteResponses];
+export type ContactsGetDetailData = {
+    body?: never;
+    path: {
+        /**
+         * The ID of the contact
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/contacts/{id}";
+};
+export type ContactsGetDetailErrors = {
+    /**
+     * Access to the contact was denied.
+     */
+    403: {
+        message?: string;
+    };
+    /**
+     * Contact not found or or insufficient privileges
+     */
+    404: {
+        message?: string;
+    };
+};
+export type ContactsGetDetailError = ContactsGetDetailErrors[keyof ContactsGetDetailErrors];
+export type ContactsGetDetailResponses = {
+    /**
+     * Success
+     */
+    200: ContactItem;
+};
+export type ContactsGetDetailResponse = ContactsGetDetailResponses[keyof ContactsGetDetailResponses];
+export type ContactsUpdateData = {
+    body?: ContactItemUpdate;
+    path: {
+        /**
+         * The ID of the contact
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/contacts/{id}";
+};
+export type ContactsUpdateErrors = {
+    /**
+     * Email address is not valid
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Insufficient privileges to update the contact
+     */
+    403: {
+        message?: string;
+    };
+    /**
+     * Contact not found or or insufficient privileges
+     */
+    404: {
+        message?: string;
+    };
+};
+export type ContactsUpdateError = ContactsUpdateErrors[keyof ContactsUpdateErrors];
+export type ContactsUpdateResponses = {
+    /**
+     * Success
+     */
+    200: ContactItem;
+};
+export type ContactsUpdateResponse = ContactsUpdateResponses[keyof ContactsUpdateResponses];
+export type ContactTestSendData = {
+    body?: never;
+    path: {
+        /**
+         * Contact id
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/contacts/test/{id}";
+};
+export type ContactTestSendErrors = {
+    /**
+     * Contact has invalid status for sending a test message
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Access to the contact was denied.
+     */
+    403: {
+        message?: string;
+    };
+    /**
+     * Contact not found or or insufficient privileges
+     */
+    404: {
+        message?: string;
+    };
+    /**
+     * Message not sent
+     */
+    409: {
+        message?: string;
+    };
+    /**
+     * Max number of test messages per day already sent
+     */
+    429: {
+        message?: string;
+    };
+};
+export type ContactTestSendError = ContactTestSendErrors[keyof ContactTestSendErrors];
+export type ContactTestSendResponses = {
+    /**
+     * Success
+     */
+    200: {
+        message?: string;
+    };
+};
+export type ContactTestSendResponse = ContactTestSendResponses[keyof ContactTestSendResponses];
+export type ContactActivateData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the contact to activate
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/contacts/{id}/activate";
+};
+export type ContactActivateErrors = {
+    /**
+     * The contact is not in inactive status, cannot be activated
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Access to the contact was denied.
+     */
+    403: {
+        message?: string;
+    };
+    /**
+     * Contact not found or or insufficient privileges
+     */
+    404: {
+        message?: string;
+    };
+};
+export type ContactActivateError = ContactActivateErrors[keyof ContactActivateErrors];
+export type ContactActivateResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type ContactActivateResponse = ContactActivateResponses[keyof ContactActivateResponses];
+export type ContactsConfirmData = {
+    /**
+     * The code to activate the contact is sent in request body
+     */
+    body?: {
+        code?: string;
+    };
+    path: {
+        /**
+         * The contact ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/contacts/confirm/{id}";
+};
+export type ContactsConfirmErrors = {
+    /**
+     * The confirmation code is missing
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * The confirmation code is invalid
+     */
+    403: {
+        message?: string;
+    };
+    /**
+     * Contact not found or or insufficient privileges
+     */
+    404: {
+        message?: string;
+    };
+    /**
+     * The contact is not waiting for confirmation
+     */
+    409: {
+        message?: string;
+    };
+};
+export type ContactsConfirmError = ContactsConfirmErrors[keyof ContactsConfirmErrors];
+export type ContactsConfirmResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type ContactsConfirmResponse = ContactsConfirmResponses[keyof ContactsConfirmResponses];
+export type ContactsRequestConfirmationCodeData = {
+    body?: never;
+    path: {
+        /**
+         * The ID of the contact
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/contacts/request-confirmation-code/{id}";
+};
+export type ContactsRequestConfirmationCodeErrors = {
+    /**
+     * This contact type does not support confirmation codes
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Access to the contact was denied.
+     */
+    403: {
+        message?: string;
+    };
+    /**
+     * Contact not found or or insufficient privileges
+     */
+    404: {
+        message?: string;
+    };
+    /**
+     * The contact is not waiting for confirmation
+     */
+    409: {
+        message?: string;
+    };
+    /**
+     * You can request a confirmation code for one contact once every 300 seconds
+     */
+    429: {
+        message?: string;
+    };
+};
+export type ContactsRequestConfirmationCodeError = ContactsRequestConfirmationCodeErrors[keyof ContactsRequestConfirmationCodeErrors];
+export type ContactsRequestConfirmationCodeResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type ContactsRequestConfirmationCodeResponse = ContactsRequestConfirmationCodeResponses[keyof ContactsRequestConfirmationCodeResponses];
+export type ContactsBlockDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the contact to unblock
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/contacts/block/{id}";
+};
+export type ContactsBlockDeleteErrors = {
+    /**
+     * You cannot change contact status to this value
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Access to the contact was denied.
+     */
+    403: {
+        message?: string;
+    };
+    /**
+     * Contact not found or or insufficient privileges
+     */
+    404: {
+        message?: string;
+    };
+};
+export type ContactsBlockDeleteError = ContactsBlockDeleteErrors[keyof ContactsBlockDeleteErrors];
+export type ContactsBlockDeleteResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type ContactsBlockDeleteResponse = ContactsBlockDeleteResponses[keyof ContactsBlockDeleteResponses];
+export type ContactsBlockPutData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the contact to block
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/contacts/block/{id}";
+};
+export type ContactsBlockPutErrors = {
+    /**
+     * You cannot change contact status to this value
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Access to the contact was denied.
+     */
+    403: {
+        message?: string;
+    };
+    /**
+     * Contact not found or or insufficient privileges
+     */
+    404: {
+        message?: string;
+    };
+};
+export type ContactsBlockPutError = ContactsBlockPutErrors[keyof ContactsBlockPutErrors];
+export type ContactsBlockPutResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type ContactsBlockPutResponse = ContactsBlockPutResponses[keyof ContactsBlockPutResponses];
+export type ContactsReplaceNotificationsWithData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the (old) contact being replaced
+         */
+        id: number;
+        /**
+         * ID of the (new) contact being used instead of the old one
+         */
+        to: number;
+    };
+    query?: never;
+    url: "/contacts/{id}/replaceInNotificationsWith/{to}";
+};
+export type ContactsReplaceNotificationsWithErrors = {
+    /**
+     * The old and new contact IDs are the same
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Access to the contact was denied.
+     */
+    403: {
+        message?: string;
+    };
+    /**
+     * Contact not found or or insufficient privileges
+     */
+    404: {
+        message?: string;
+    };
+};
+export type ContactsReplaceNotificationsWithError = ContactsReplaceNotificationsWithErrors[keyof ContactsReplaceNotificationsWithErrors];
+export type ContactsReplaceNotificationsWithResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type ContactsReplaceNotificationsWithResponse = ContactsReplaceNotificationsWithResponses[keyof ContactsReplaceNotificationsWithResponses];
+export type FoldersListData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/folders";
+};
+export type FoldersListErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type FoldersListError = FoldersListErrors[keyof FoldersListErrors];
+export type FoldersListResponses = {
+    /**
+     * Success
+     */
+    200: Array<FolderItem>;
+};
+export type FoldersListResponse = FoldersListResponses[keyof FoldersListResponses];
+export type FolderPostData = {
+    /**
+     * Folder attributes
+     */
+    body: FolderRequestItem;
+    path?: never;
+    query?: never;
+    url: "/folders";
+};
+export type FolderPostErrors = {
+    /**
+     * Invalid data
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Not permitted to create
+     */
+    403: Forbidden;
+};
+export type FolderPostError = FolderPostErrors[keyof FolderPostErrors];
+export type FolderPostResponses = {
+    /**
+     * Success
+     */
+    201: FolderItem;
+};
+export type FolderPostResponse = FolderPostResponses[keyof FolderPostResponses];
+export type FolderDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Folder id
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/folders/{id}";
+};
+export type FolderDeleteErrors = {
+    /**
+     * Not permitted to delete
+     */
+    403: Forbidden;
+    /**
+     * Folder not found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type FolderDeleteError = FolderDeleteErrors[keyof FolderDeleteErrors];
+export type FolderDeleteResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type FolderDeleteResponse = FolderDeleteResponses[keyof FolderDeleteResponses];
+export type FolderGetData = {
+    body?: never;
+    path: {
+        /**
+         * Folder id
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/folders/{id}";
+};
+export type FolderGetErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Folder not found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type FolderGetError = FolderGetErrors[keyof FolderGetErrors];
+export type FolderGetResponses = {
+    /**
+     * Success
+     */
+    200: FolderItem;
+};
+export type FolderGetResponse = FolderGetResponses[keyof FolderGetResponses];
+export type FolderUpdateData = {
+    /**
+     * Folder attributes
+     */
+    body: FolderRequestItem;
+    path: {
+        /**
+         * Folder id
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/folders/{id}";
+};
+export type FolderUpdateErrors = {
+    /**
+     * Invalid data
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Not permitted to update
+     */
+    403: Forbidden;
+    /**
+     * Folder not found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type FolderUpdateError = FolderUpdateErrors[keyof FolderUpdateErrors];
+export type FolderUpdateResponses = {
+    /**
+     * Success
+     */
+    200: FolderItem;
+};
+export type FolderUpdateResponse = FolderUpdateResponses[keyof FolderUpdateResponses];
+export type FolderAccessGetData = {
+    body?: never;
+    path: {
+        /**
+         * User id permissions are fetched for
+         */
+        user: number;
+    };
+    query?: never;
+    url: "/folders/access/{user}";
+};
+export type FolderAccessGetErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Not found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type FolderAccessGetError = FolderAccessGetErrors[keyof FolderAccessGetErrors];
+export type FolderAccessGetResponses = {
+    /**
+     * Success
+     */
+    200: Array<FolderItem>;
+};
+export type FolderAccessGetResponse = FolderAccessGetResponses[keyof FolderAccessGetResponses];
+export type LocationsDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Location ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/locations/{id}";
+};
+export type LocationsDeleteErrors = {
+    /**
+     * Invalid location - cannot be deleted (is not empty or is used)
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Not found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type LocationsDeleteError = LocationsDeleteErrors[keyof LocationsDeleteErrors];
+export type LocationsDeleteResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type LocationsDeleteResponse = LocationsDeleteResponses[keyof LocationsDeleteResponses];
+export type LocationsGetData = {
+    body?: never;
+    path: {
+        /**
+         * Location ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/locations/{id}";
+};
+export type LocationsGetErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Not found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type LocationsGetError = LocationsGetErrors[keyof LocationsGetErrors];
+export type LocationsGetResponses = {
+    /**
+     * Success
+     */
+    200: Location;
+};
+export type LocationsGetResponse = LocationsGetResponses[keyof LocationsGetResponses];
+export type LocationsPostData = {
+    /**
+     * Location object.
+     */
+    body: LocationDraft;
+    path: {
+        /**
+         * Location ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/locations/{id}";
+};
+export type LocationsPostErrors = {
+    /**
+     * Invalid request - missing or invalid data
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Parent location not found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type LocationsPostError = LocationsPostErrors[keyof LocationsPostErrors];
+export type LocationsPostResponses = {
+    /**
+     * Success
+     */
+    200: Location;
+};
+export type LocationsPostResponse = LocationsPostResponses[keyof LocationsPostResponses];
+export type LocationsGetByTypeData = {
+    body?: never;
+    path: {
+        /**
+         * Location type filter
+         */
+        type: "private" | "public" | "all";
+    };
+    query?: never;
+    url: "/locations/{type}";
+};
+export type LocationsGetByTypeErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type LocationsGetByTypeError = LocationsGetByTypeErrors[keyof LocationsGetByTypeErrors];
+export type LocationsGetByTypeResponses = {
+    /**
+     * Success
+     */
+    200: Array<Location>;
+};
+export type LocationsGetByTypeResponse = LocationsGetByTypeResponses[keyof LocationsGetByTypeResponses];
+export type LocationsGetAllData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/locations";
+};
+export type LocationsGetAllErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type LocationsGetAllError = LocationsGetAllErrors[keyof LocationsGetAllErrors];
+export type LocationsGetAllResponses = {
+    /**
+     * Success
+     */
+    200: Array<Location>;
+};
+export type LocationsGetAllResponse = LocationsGetAllResponses[keyof LocationsGetAllResponses];
+export type LocationsCreateData = {
+    /**
+     * Location object.
+     */
+    body: LocationDraft;
+    path?: never;
+    query?: never;
+    url: "/locations";
+};
+export type LocationsCreateErrors = {
+    /**
+     * Invalid request - missing or invalid data
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Parent location not found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type LocationsCreateError = LocationsCreateErrors[keyof LocationsCreateErrors];
+export type LocationsCreateResponses = {
+    /**
+     * Success
+     */
+    200: Location;
+};
+export type LocationsCreateResponse = LocationsCreateResponses[keyof LocationsCreateResponses];
+export type LocationsLeafGetFilterData = {
+    body?: never;
+    path: {
+        /**
+         * Location filter
+         */
+        filter: "private" | "public" | "all";
+    };
+    query?: never;
+    url: "/locations/leaf/{filter}";
+};
+export type LocationsLeafGetFilterErrors = {
+    /**
+     * Invalid request - invalid filter
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type LocationsLeafGetFilterError = LocationsLeafGetFilterErrors[keyof LocationsLeafGetFilterErrors];
+export type LocationsLeafGetFilterResponses = {
+    /**
+     * Success
+     */
+    200: Array<Location>;
+};
+export type LocationsLeafGetFilterResponse = LocationsLeafGetFilterResponses[keyof LocationsLeafGetFilterResponses];
+export type LogGetData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * List of monitors to query. If both 'monitors' and 'folders' are omitted,
+         * query all monitors. Format: Monitor name (string) or monitor ID (integer).
+         */
+        monitor?: Array<string>;
+        /**
+         * List of folders to query. If both 'monitors' and 'folders' are omitted,
+         * query all monitors. Format: Folder name (string) or folder ID (integer).
+         */
+        folder?: Array<string>;
+        /**
+         * List of locations to filter by. Format: Location name (string) or location ID (integer).
+         */
+        location?: Array<string>;
+        /**
+         * Start of interval. Format: ISO 8601 date and time or event ID.
+         */
+        from?: string;
+        /**
+         * End of interval. Format: ISO 8601 date and time or event ID.
+         */
+        to?: string;
+        /**
+         * Filter results by status.
+         */
+        status?: "error" | "confirmed_error";
+        /**
+         * Show extended results.
+         */
+        extended?: boolean;
+        /**
+         * Limit number of results.
+         */
+        limit?: number;
+    };
+    url: "/log";
+};
+export type LogGetErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type LogGetError = LogGetErrors[keyof LogGetErrors];
+export type LogGetResponses = {
+    /**
+     * Success
+     */
+    200: Array<LogEvent>;
+};
+export type LogGetResponse = LogGetResponses[keyof LogGetResponses];
+export type LogGetEventData = {
+    body?: never;
+    path: {
+        /**
+         * Event ID
+         */
+        id: string;
+    };
+    query?: never;
+    url: "/log/{id}";
+};
+export type LogGetEventErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type LogGetEventError = LogGetEventErrors[keyof LogGetEventErrors];
+export type LogGetEventResponses = {
+    /**
+     * Success
+     */
+    200: LogEvent;
+};
+export type LogGetEventResponse = LogGetEventResponses[keyof LogGetEventResponses];
+export type MaintenanceGetData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Include also expired maintenance windows.
+         */
+        includeExpired?: boolean;
+    };
+    url: "/maintenances";
+};
+export type MaintenanceGetErrors = {
+    /**
+     * Insufficient permissions
+     */
+    403: {
+        message?: string;
+    };
+};
+export type MaintenanceGetError = MaintenanceGetErrors[keyof MaintenanceGetErrors];
+export type MaintenanceGetResponses = {
+    /**
+     * Success
+     */
+    200: MaintenanceCatalogue;
+};
+export type MaintenanceGetResponse = MaintenanceGetResponses[keyof MaintenanceGetResponses];
+export type MaintenancesCreateData = {
+    /**
+     * `name` and `windows` is required.
+     */
+    body: MaintenanceItemCreate;
+    path?: never;
+    query?: never;
+    url: "/maintenances";
+};
+export type MaintenancesCreateErrors = {
+    /**
+     * Wrong values were passed
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Insufficient permissions
+     */
+    403: {
+        message?: string;
+    };
+};
+export type MaintenancesCreateError = MaintenancesCreateErrors[keyof MaintenancesCreateErrors];
+export type MaintenancesCreateResponses = {
+    /**
+     * Success
+     */
+    201: MaintenanceItem;
+};
+export type MaintenancesCreateResponse = MaintenancesCreateResponses[keyof MaintenancesCreateResponses];
+export type MaintenanceDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Maintenance ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/maintenances/{id}";
+};
+export type MaintenanceDeleteErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Maintenance not found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type MaintenanceDeleteError = MaintenanceDeleteErrors[keyof MaintenanceDeleteErrors];
+export type MaintenanceDeleteResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type MaintenanceDeleteResponse = MaintenanceDeleteResponses[keyof MaintenanceDeleteResponses];
+export type MaintenanceGetDetailData = {
+    body?: never;
+    path: {
+        /**
+         * The maintenance window ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/maintenances/{id}";
+};
+export type MaintenanceGetDetailErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Not Found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type MaintenanceGetDetailError = MaintenanceGetDetailErrors[keyof MaintenanceGetDetailErrors];
+export type MaintenanceGetDetailResponses = {
+    /**
+     * Success
+     */
+    200: MaintenanceItem;
+};
+export type MaintenanceGetDetailResponse = MaintenanceGetDetailResponses[keyof MaintenanceGetDetailResponses];
+export type MaintenancesUpdateData = {
+    /**
+     * Values not specified are not modified
+     */
+    body: MaintenanceItem;
+    path: {
+        /**
+         * The maintenance window ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/maintenances/{id}";
+};
+export type MaintenancesUpdateErrors = {
+    /**
+     * Wrong values were passed
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Insufficient permissions
+     */
+    403: {
+        message?: string;
+    };
+};
+export type MaintenancesUpdateError = MaintenancesUpdateErrors[keyof MaintenancesUpdateErrors];
+export type MaintenancesUpdateResponses = {
+    /**
+     * Success
+     */
+    200: MaintenanceItem;
+};
+export type MaintenancesUpdateResponse = MaintenancesUpdateResponses[keyof MaintenancesUpdateResponses];
+export type MaintenanceGetWindowsData = {
+    body?: never;
+    path: {
+        /**
+         * The maintenance window ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/maintenances/{id}/windows";
+};
+export type MaintenanceGetWindowsErrors = {
+    /**
+     * Not Found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type MaintenanceGetWindowsError = MaintenanceGetWindowsErrors[keyof MaintenanceGetWindowsErrors];
+export type MaintenanceGetWindowsResponses = {
+    /**
+     * Success
+     */
+    200: Array<MaintenanceWindowItem>;
+};
+export type MaintenanceGetWindowsResponse = MaintenanceGetWindowsResponses[keyof MaintenanceGetWindowsResponses];
+export type MaintenancesPostWindowsData = {
+    body?: WindowItemCreate;
+    path: {
+        /**
+         * The ID of the maintenance window
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/maintenances/{id}/windows";
+};
+export type MaintenancesPostWindowsErrors = {
+    /**
+     * Wrong values were passed
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Insufficient permissions
+     */
+    403: {
+        message?: string;
+    };
+    /**
+     * Not Found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type MaintenancesPostWindowsError = MaintenancesPostWindowsErrors[keyof MaintenancesPostWindowsErrors];
+export type MaintenancesPostWindowsResponses = {
+    /**
+     * Success
+     */
+    201: MaintenanceWindowItem;
+};
+export type MaintenancesPostWindowsResponse = MaintenancesPostWindowsResponses[keyof MaintenancesPostWindowsResponses];
+export type MaintenanceDeleteWindowsData = {
+    body?: never;
+    path: {
+        /**
+         * The maintenance window ID that the time window belongs to
+         */
+        maintenanceWindowId: number;
+        /**
+         * The time window to delete
+         */
+        timeWindowId: number;
+    };
+    query?: never;
+    url: "/maintenances/{maintenanceWindowId}/windows/{timeWindowId}";
+};
+export type MaintenanceDeleteWindowsErrors = {
+    /**
+     * Insufficient permissions
+     */
+    403: {
+        message?: string;
+    };
+    /**
+     * Not Found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type MaintenanceDeleteWindowsError = MaintenanceDeleteWindowsErrors[keyof MaintenanceDeleteWindowsErrors];
+export type MaintenanceDeleteWindowsResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type MaintenanceDeleteWindowsResponse = MaintenanceDeleteWindowsResponses[keyof MaintenanceDeleteWindowsResponses];
+export type MaintenanceGetWindowsDetailData = {
+    body?: never;
+    path: {
+        /**
+         * The maintenance window ID
+         */
+        maintenanceWindowId: number;
+        /**
+         * The time window ID
+         */
+        timeWindowId: number;
+    };
+    query?: never;
+    url: "/maintenances/{maintenanceWindowId}/windows/{timeWindowId}";
+};
+export type MaintenanceGetWindowsDetailErrors = {
+    /**
+     * Not Found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type MaintenanceGetWindowsDetailError = MaintenanceGetWindowsDetailErrors[keyof MaintenanceGetWindowsDetailErrors];
+export type MaintenanceGetWindowsDetailResponses = {
+    /**
+     * Success
+     */
+    200: MaintenanceWindowItem;
+};
+export type MaintenanceGetWindowsDetailResponse = MaintenanceGetWindowsDetailResponses[keyof MaintenanceGetWindowsDetailResponses];
+export type MaintenanceUpdateWindowsDetailData = {
+    body?: WindowItemCreate;
+    path: {
+        /**
+         * The maintenance window ID
+         */
+        maintenanceWindowId: number;
+        /**
+         * The individual window ID
+         */
+        timeWindowId: number;
+    };
+    query?: never;
+    url: "/maintenances/{maintenanceWindowId}/windows/{timeWindowId}";
+};
+export type MaintenanceUpdateWindowsDetailErrors = {
+    /**
+     * Not Found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type MaintenanceUpdateWindowsDetailError = MaintenanceUpdateWindowsDetailErrors[keyof MaintenanceUpdateWindowsDetailErrors];
+export type MaintenanceUpdateWindowsDetailResponses = {
+    /**
+     * Success
+     */
+    200: MaintenanceWindowItem;
+};
+export type MaintenanceUpdateWindowsDetailResponse = MaintenanceUpdateWindowsDetailResponses[keyof MaintenanceUpdateWindowsDetailResponses];
+export type MaintenancesImmediateDeleteData = {
+    /**
+     * Ids of monitors the immediate maintenance should be finished. You need update permission for these monitors
+     */
+    body: Array<number>;
+    path?: never;
+    query?: never;
+    url: "/maintenances/immediate";
+};
+export type MaintenancesImmediateDeleteErrors = {
+    /**
+     * Wrong values were passed
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Insufficient permissions
+     */
+    403: Forbidden;
+};
+export type MaintenancesImmediateDeleteError = MaintenancesImmediateDeleteErrors[keyof MaintenancesImmediateDeleteErrors];
+export type MaintenancesImmediateDeleteResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type MaintenancesImmediateDeleteResponse = MaintenancesImmediateDeleteResponses[keyof MaintenancesImmediateDeleteResponses];
+export type MaintenancesImmediatePutData = {
+    /**
+     * Immediate maintenance window
+     */
+    body: MaintenanceItemImmediateCreate;
+    path?: never;
+    query?: never;
+    url: "/maintenances/immediate";
+};
+export type MaintenancesImmediatePutErrors = {
+    /**
+     * Wrong values were passed
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Insufficient permissions
+     */
+    403: Forbidden;
+};
+export type MaintenancesImmediatePutError = MaintenancesImmediatePutErrors[keyof MaintenancesImmediatePutErrors];
+export type MaintenancesImmediatePutResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type MaintenancesImmediatePutResponse = MaintenancesImmediatePutResponses[keyof MaintenancesImmediatePutResponses];
+export type MessagesListData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Filter alerts related to a monitor.
+         */
+        monitorId?: number;
+        /**
+         * Filter alerts related to monitors in a folder.
+         */
+        folderId?: number;
+        /**
+         * Select messages that represent some monitor alert or not. Note: expire
+         * certificate notifications are not alerts - they are not bound to a particular monitor or contact.
+         */
+        isAlert?: boolean;
+        /**
+         * Contact ID. You need contact update permission to filter by the contact.
+         */
+        contactId?: number;
+        /**
+         * Select messages by message type.
+         */
+        type?: "email" | "sms" | "phone" | "action" | "rss";
+        /**
+         * Select messages by message status.
+         */
+        status?: "deleted" | "queued" | "gateway" | "provider" | "device" | "accepted" | "queued-no-fallback" | "undeliverable" | "suppressed";
+        /**
+         * Select messages by date and time when it was sent. It can also be provided as positive integer - the oldest message ID.
+         */
+        from?: string;
+        /**
+         * Select messages by date and time when it was sent. It can also be provided as positive integer - the newest message ID.
+         */
+        to?: string;
+        /**
+         * Max number of results to return.
+         */
+        limit?: number;
+    };
+    url: "/messages";
+};
+export type MessagesListErrors = {
+    /**
+     * Bad request
+     */
+    400: unknown;
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Not found
+     */
+    404: unknown;
+};
+export type MessagesListError = MessagesListErrors[keyof MessagesListErrors];
+export type MessagesListResponses = {
+    /**
+     * Success
+     */
+    200: Array<MessageItem>;
+};
+export type MessagesListResponse = MessagesListResponses[keyof MessagesListResponses];
+export type MessageGetData = {
+    body?: never;
+    path: {
+        /**
+         * Message id
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/messages/{id}";
+};
+export type MessageGetErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type MessageGetError = MessageGetErrors[keyof MessageGetErrors];
+export type MessageGetResponses = {
+    /**
+     * Success
+     */
+    200: MessageItem;
+};
+export type MessageGetResponse = MessageGetResponses[keyof MessageGetResponses];
+export type MonitorGetAllData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Flag for reading the simple and fast list of monitor frames. If true, the
+         * simple monitor schemas (MonitorFrame) are returned in the response (which
+         * should be slightly faster), the full schema (Monitor) otherwise
+         */
+        framesOnly?: boolean;
+        /**
+         * Flag for sending response together with the pagination information. If true,
+         * the MonitorsPage schema is returned with pagination information, the simple
+         * array of matching monitors otherwise.
+         */
+        pagination?: boolean;
+        /**
+         * Monitor ID or comma separated list of monitor IDs.
+         */
+        monitorId?: string;
+        /**
+         * Folder ID. Use 0 for monitors out of folder.
+         */
+        folderId?: number;
+        /**
+         * Select monitors user has this level of access.
+         */
+        accessLevel?: "view" | "update" | "create-delete";
+        /**
+         * Select monitors by type.
+         */
+        type?: "browser" | "connect" | "dnsa" | "dnsns" | "dns" | "domain" | "ftp" | "ftps" | "http" | "https" | "imap" | "ldap" | "ping" | "plugin" | "pop3" | "scp" | "script" | "sftp" | "sip" | "smtp" | "telnet" | "webdriver";
+        /**
+         * Flag for filtering active monitors only.
+         */
+        isActive?: boolean;
+        /**
+         * Flag for filtering failing monitors only. With false both the active non-failing monitors and inactive monitors are returned.
+         */
+        inError?: boolean;
+        /**
+         * Flag for filtering monitors with unhealthy pool of stations.
+         */
+        isUnhealthy?: boolean;
+        /**
+         * Flag for filtering monitors configured to use a proxy or not.
+         */
+        proxy?: "none" | "system" | "custom";
+        /**
+         * Flag for filtering monitors with authentication enabled.
+         */
+        hasAuthentication?: boolean;
+        /**
+         * Select monitors by username used in authentication.
+         */
+        username?: string;
+        /**
+         * Select monitors that are tagged by one of this tags (pipe separated list).
+         */
+        tag?: string;
+        /**
+         * Select monitors by name. See also the nameMatchType option below.
+         */
+        name?: string;
+        /**
+         * Match type for the monitor-by-name filtering. I nameMatchType is 'full'
+         * (or empty as this is default) the name must be equal to the filter value,
+         * if 'partial' the name must contain the filter value.
+         */
+        nameMatchType?: "full" | "partial";
+        /**
+         * Monitoring location ID.
+         */
+        locationId?: number;
+        /**
+         * Monitoring station ID.
+         */
+        stationId?: number;
+        /**
+         * Flag for filtering by station or monitor ID. If true, find only monitors
+         * explicitly configured for the location, i.e. do not select monitors with
+         * empty (default) pool. Default is false for public stations / locations, true for OPMS.
+         */
+        explicitPoolOnly?: boolean;
+        /**
+         * Low monitor ID limit for pagination (needs sorting by monitor ID)
+         */
+        from?: number;
+        /**
+         * High monitor ID limit for pagination (needs sorting by monitor ID)
+         */
+        to?: number;
+        /**
+         * Max number of results to return.
+         */
+        limit?: number;
+        /**
+         * Zero based offset for pagination. Limit is required if offset is set.
+         */
+        offset?: number;
+        /**
+         * Order by string.
+         */
+        order?: string;
+    };
+    url: "/monitors";
+};
+export type MonitorGetAllErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Not found
+     */
+    404: {
+        message?: string;
+    };
+};
+export type MonitorGetAllError = MonitorGetAllErrors[keyof MonitorGetAllErrors];
+export type MonitorGetAllResponses = {
+    /**
+     * Success. The result returned depends on the framesOnly and pagination parameters.
+     */
+    200: MonitorsPage | Array<Browser | Connect | Dns | Dnsa | Dnsns | Domain | Ftp | Ftps | Http | Https | Imap | Ldap | Ping | Plugin | Pop3 | Scp | Script | Sftp | Sip | Smtp | Telnet | Webdriver | MonitorFrame>;
+};
+export type MonitorGetAllResponse = MonitorGetAllResponses[keyof MonitorGetAllResponses];
+export type MonitorCreateData = {
+    /**
+     * Monitor settings
+     */
+    body: BrowserCreate | ConnectCreate | DnsCreate | DnsaCreate | DnsnsCreate | DomainCreate | FtpCreate | FtpsCreate | HttpCreate | HttpsCreate | ImapCreate | LdapCreate | PingCreate | PluginCreate | Pop3Create | ScpCreate | ScriptCreate | SftpCreate | SipCreate | SmtpCreate | TelnetCreate | WebdriverCreate;
+    path?: never;
+    query?: never;
+    url: "/monitors";
+};
+export type MonitorCreateErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        status?: string;
+        message?: string;
+        data?: {
+            details?: unknown;
+        };
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type MonitorCreateError = MonitorCreateErrors[keyof MonitorCreateErrors];
+export type MonitorCreateResponses = {
+    /**
+     * Success
+     */
+    201: {
+        monitorId?: number;
+    };
+};
+export type MonitorCreateResponse = MonitorCreateResponses[keyof MonitorCreateResponses];
+export type MonitorDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Monitor ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/monitors/{id}";
+};
+export type MonitorDeleteErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Not found
+     */
+    404: unknown;
+};
+export type MonitorDeleteError = MonitorDeleteErrors[keyof MonitorDeleteErrors];
+export type MonitorDeleteResponses = {
+    /**
+     * Success
+     */
+    200: unknown;
+};
+export type MonitorGetData = {
+    body?: never;
+    path: {
+        /**
+         * Monitor ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/monitors/{id}";
+};
+export type MonitorGetErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type MonitorGetError = MonitorGetErrors[keyof MonitorGetErrors];
+export type MonitorGetResponses = {
+    /**
+     * Success
+     */
+    200: Browser | Connect | Dns | Dnsa | Dnsns | Domain | Ftp | Ftps | Http | Https | Imap | Ldap | Ping | Plugin | Pop3 | Scp | Script | Sftp | Sip | Smtp | Telnet | Webdriver;
+};
+export type MonitorGetResponse = MonitorGetResponses[keyof MonitorGetResponses];
+export type MonitorUpdateData = {
+    /**
+     * Monitor settings
+     */
+    body: BrowserUpdate | ConnectUpdate | DnsUpdate | DnsaUpdate | DnsnsUpdate | DomainUpdate | FtpUpdate | FtpsUpdate | HttpUpdate | HttpsUpdate | ImapUpdate | LdapUpdate | PingUpdate | PluginUpdate | Pop3Update | ScpUpdate | ScriptUpdate | SftpUpdate | SipUpdate | SmtpUpdate | TelnetUpdate | WebdriverUpdate;
+    path: {
+        /**
+         * Monitor ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/monitors/{id}";
+};
+export type MonitorUpdateErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        status?: string;
+        message?: string;
+        data?: {
+            details?: unknown;
+        };
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type MonitorUpdateError = MonitorUpdateErrors[keyof MonitorUpdateErrors];
+export type MonitorUpdateResponses = {
+    /**
+     * Success
+     */
+    200: {
+        message?: string;
+    };
+};
+export type MonitorUpdateResponse = MonitorUpdateResponses[keyof MonitorUpdateResponses];
+export type MonitorActivateData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * List of monitors to activate. Format: Comma-separated monitor IDs or monitor names
+         */
+        monitor: Array<string>;
+    };
+    url: "/monitors/activate";
+};
+export type MonitorActivateErrors = {
+    /**
+     * Bad request
+     */
+    400: unknown;
+    /**
+     * Subscription not enough for activation
+     */
+    402: unknown;
+    /**
+     * Not permitted
+     */
+    403: unknown;
+    /**
+     * Not found
+     */
+    404: unknown;
+};
+export type MonitorActivateResponses = {
+    /**
+     * Successful activation
+     */
+    200: {
+        responses?: Array<{
+            id?: unknown;
+            status?: number;
+            resource?: unknown;
+            message?: string;
+        }>;
+        metadata?: BulkResponseMetadata;
+    };
+    /**
+     * Multiple results. If the results in the bulk response have a mix of different HTTP
+     * codes, the final HTTP code will be 207 Multi-status. In that case check the results
+     * carefully one by one.
+     */
+    207: {
+        status?: string;
+        message?: string;
+        data?: BulkResponse;
+    };
+};
+export type MonitorActivateResponse = MonitorActivateResponses[keyof MonitorActivateResponses];
+export type MonitorDeactivateData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * List of monitors to deactivate. Format: Comma-separated monitor IDs or monitor names
+         */
+        monitor: Array<string>;
+    };
+    url: "/monitors/deactivate";
+};
+export type MonitorDeactivateErrors = {
+    /**
+     * Bad request
+     */
+    400: unknown;
+    /**
+     * Not permitted
+     */
+    403: unknown;
+    /**
+     * Not found
+     */
+    404: unknown;
+};
+export type MonitorDeactivateResponses = {
+    /**
+     * A successful deactivation
+     */
+    200: {
+        responses?: Array<{
+            id?: unknown;
+            status?: number;
+            resource?: unknown;
+            message?: string;
+        }>;
+        metadata?: BulkResponseMetadata;
+    };
+    /**
+     * Multiple results. If the results in the bulk response have a mix of different HTTP codes,
+     *
+     * the final HTTP code will be 207 Multi-status. In that case check the results carefully one by one.
+     */
+    207: {
+        status?: string;
+        message?: string;
+        data?: BulkResponse;
+    };
+};
+export type MonitorDeactivateResponse = MonitorDeactivateResponses[keyof MonitorDeactivateResponses];
+export type OauthClientTokensListData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/oauth2";
+};
+export type OauthClientTokensListErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type OauthClientTokensListError = OauthClientTokensListErrors[keyof OauthClientTokensListErrors];
+export type OauthClientTokensListResponses = {
+    /**
+     * Success
+     */
+    200: Array<OauthClientCredentialsItem>;
+};
+export type OauthClientTokensListResponse = OauthClientTokensListResponses[keyof OauthClientTokensListResponses];
+export type OauthClientTokensCreateData = {
+    /**
+     * The request body. Name is required, everything else is optional.
+     */
+    body: {
+        name?: string;
+        valid_until?: string;
+        access_token_validity?: number;
+        refresh_token_validity?: number;
+    };
+    path?: never;
+    query?: never;
+    url: "/oauth2";
+};
+export type OauthClientTokensCreateErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type OauthClientTokensCreateError = OauthClientTokensCreateErrors[keyof OauthClientTokensCreateErrors];
+export type OauthClientTokensCreateResponses = {
+    /**
+     * Success
+     */
+    201: {
+        status?: string;
+        data?: {
+            id?: number;
+            name?: string;
+            client_id?: string;
+            valid_until?: string;
+            access_token_validity?: number;
+            refresh_token_validity?: number;
+            client_secret?: string;
+        };
+    };
+};
+export type OauthClientTokensCreateResponse = OauthClientTokensCreateResponses[keyof OauthClientTokensCreateResponses];
+export type OauthClientTokensDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * The ID of the credentials to delete
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/oauth2/{id}";
+};
+export type OauthClientTokensDeleteErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Not found
+     */
+    404: OauthClientCredentialsNotFound;
+};
+export type OauthClientTokensDeleteError = OauthClientTokensDeleteErrors[keyof OauthClientTokensDeleteErrors];
+export type OauthClientTokensDeleteResponses = {
+    /**
+     * Success
+     */
+    200: {
+        message?: string;
+    };
+};
+export type OauthClientTokensDeleteResponse = OauthClientTokensDeleteResponses[keyof OauthClientTokensDeleteResponses];
+export type OauthClientTokensGetData = {
+    body?: never;
+    path: {
+        /**
+         * The ID of the credentials
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/oauth2/{id}";
+};
+export type OauthClientTokensGetErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Not found
+     */
+    404: OauthClientCredentialsNotFound;
+};
+export type OauthClientTokensGetError = OauthClientTokensGetErrors[keyof OauthClientTokensGetErrors];
+export type OauthClientTokensGetResponses = {
+    /**
+     * Success
+     */
+    200: OauthClientCredentialsItem;
+};
+export type OauthClientTokensGetResponse = OauthClientTokensGetResponses[keyof OauthClientTokensGetResponses];
+export type OauthClientTokensUpdateData = {
+    /**
+     * The request body. Name is required, everything else is optional.
+     */
+    body: {
+        name?: string;
+        valid_until?: string;
+        access_token_validity?: number;
+        refresh_token_validity?: number;
+    };
+    path: {
+        /**
+         * The ID of the credentials to update
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/oauth2/{id}";
+};
+export type OauthClientTokensUpdateErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Not found
+     */
+    404: OauthClientCredentialsNotFound;
+};
+export type OauthClientTokensUpdateError = OauthClientTokensUpdateErrors[keyof OauthClientTokensUpdateErrors];
+export type OauthClientTokensUpdateResponses = {
+    /**
+     * Success
+     */
+    200: {
+        message?: string;
+        data?: OauthClientCredentialsItem;
+    };
+};
+export type OauthClientTokensUpdateResponse = OauthClientTokensUpdateResponses[keyof OauthClientTokensUpdateResponses];
+export type OauthTokenDeleteCurrentData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/oauth2/token";
+};
+export type OauthTokenDeleteCurrentErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        error?: string;
+    };
+};
+export type OauthTokenDeleteCurrentError = OauthTokenDeleteCurrentErrors[keyof OauthTokenDeleteCurrentErrors];
+export type OauthTokenDeleteCurrentResponses = {
+    /**
+     * Success
+     */
+    200: unknown;
+};
+export type OauthGetTokenListData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Flag for including expired tokens. By default expired tokens are not returned.
+         */
+        expired?: boolean;
+    };
+    url: "/oauth2/token";
+};
+export type OauthGetTokenListErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: unknown;
+};
+export type OauthGetTokenListResponses = {
+    /**
+     * Success
+     */
+    200: Array<OauthToken>;
+};
+export type OauthGetTokenListResponse = OauthGetTokenListResponses[keyof OauthGetTokenListResponses];
+export type OauthCreateTokenData = {
+    body?: {
+        /**
+         * The grant type according to OAuth2 specification
+         */
+        grant_type: "authorization_code" | "client_credentials" | "refresh_token";
+        /**
+         * The client ID, required for client_credentials and authorization_code grants.
+         */
+        client_id?: string;
+        /**
+         * The client secret, required for client_credentials, optional for authorization_code.
+         */
+        client_secret?: string;
+        /**
+         * Refresh token user for refresh_token grant.
+         */
+        refresh_token?: string;
+        /**
+         * Authorization code used in authorization_code grant.
+         */
+        code?: string;
+        /**
+         * Redirect URI used in authorization_code grant.
+         */
+        redirect_uri?: string;
+    };
+    path?: never;
+    query?: never;
+    url: "/oauth2/token";
+};
+export type OauthCreateTokenErrors = {
+    /**
+     * Invalid data sent
+     */
+    400: {
+        /**
+         * The error code
+         */
+        error?: string;
+        /**
+         * The error message
+         */
+        error_description?: string;
+    };
+    /**
+     * Invalid credentials
+     */
+    401: {
+        /**
+         * The error code
+         */
+        error?: string;
+        /**
+         * The error message
+         */
+        error_description?: string;
+    };
+};
+export type OauthCreateTokenError = OauthCreateTokenErrors[keyof OauthCreateTokenErrors];
+export type OauthCreateTokenResponses = {
+    /**
+     * Success - refresh_token and client_credentials grants.
+     */
+    200: {
+        /**
+         * The new access token
+         */
+        access_token?: string;
+        /**
+         * Always 'bearer'
+         */
+        token_type?: string;
+        /**
+         * The remaining time in seconds until access token expires
+         */
+        expires_in?: number;
+        /**
+         * A token that can be used to refresh the access token
+         */
+        refresh_token?: string;
+        /**
+         * The remaining time in seconds until refresh token expires
+         */
+        refresh_token_expires_in?: number;
+    };
+};
+export type OauthCreateTokenResponse = OauthCreateTokenResponses[keyof OauthCreateTokenResponses];
+export type OauthGetRefreshTokenListData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Flag for including expired tokens. By default expired tokens are not returned.
+         */
+        expired?: boolean;
+    };
+    url: "/oauth2/refreshtoken";
+};
+export type OauthGetRefreshTokenListErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: unknown;
+};
+export type OauthGetRefreshTokenListResponses = {
+    /**
+     * Success
+     */
+    200: Array<OauthToken>;
+};
+export type OauthGetRefreshTokenListResponse = OauthGetRefreshTokenListResponses[keyof OauthGetRefreshTokenListResponses];
+export type OauthTokenDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * The access token or the ID of access token to invalidate
+         */
+        token: string | number;
+    };
+    query?: never;
+    url: "/oauth2/token/{token}";
+};
+export type OauthTokenDeleteErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        error?: string;
+    };
+};
+export type OauthTokenDeleteError = OauthTokenDeleteErrors[keyof OauthTokenDeleteErrors];
+export type OauthTokenDeleteResponses = {
+    /**
+     * Success
+     */
+    200: unknown;
+};
+export type OauthRefreshTokenDeleteIdData = {
+    body?: never;
+    path: {
+        id: number;
+    };
+    query?: never;
+    url: "/oauth2/refreshtoken/{id}";
+};
+export type OauthRefreshTokenDeleteIdErrors = {
+    /**
+     * Bad request
+     */
+    400: unknown;
+    /**
+     * Not found
+     */
+    404: unknown;
+};
+export type OauthRefreshTokenDeleteIdResponses = {
+    /**
+     * Success
+     */
+    200: unknown;
+};
+export type OauthTokenCognateDeleteCurrentData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/oauth2/cognate-tokens";
+};
+export type OauthTokenCognateDeleteCurrentErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        error?: string;
+    };
+};
+export type OauthTokenCognateDeleteCurrentError = OauthTokenCognateDeleteCurrentErrors[keyof OauthTokenCognateDeleteCurrentErrors];
+export type OauthTokenCognateDeleteCurrentResponses = {
+    /**
+     * Success
+     */
+    200: unknown;
+};
+export type OauthTokenCognateDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * The access token, if empty access token from current request is used
+         */
+        token: string;
+    };
+    query?: never;
+    url: "/oauth2/cognate-tokens/{token}";
+};
+export type OauthTokenCognateDeleteErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        error?: string;
+    };
+};
+export type OauthTokenCognateDeleteError = OauthTokenCognateDeleteErrors[keyof OauthTokenCognateDeleteErrors];
+export type OauthTokenCognateDeleteResponses = {
+    /**
+     * Success
+     */
+    200: unknown;
+};
+export type SettingsGetData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/settings";
+};
+export type SettingsGetErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type SettingsGetError = SettingsGetErrors[keyof SettingsGetErrors];
+export type SettingsGetResponses = {
+    /**
+     * Success
+     */
+    200: Array<SettingsItem>;
+};
+export type SettingsGetResponse = SettingsGetResponses[keyof SettingsGetResponses];
+export type SettingsGetDetailData = {
+    body?: never;
+    path: {
+        /**
+         * The setting name
+         */
+        name: string;
+    };
+    query?: never;
+    url: "/settings/{name}";
+};
+export type SettingsGetDetailErrors = {
+    /**
+     * Invalid parameter name
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type SettingsGetDetailError = SettingsGetDetailErrors[keyof SettingsGetDetailErrors];
+export type SettingsGetDetailResponses = {
+    /**
+     * Success
+     */
+    200: SettingsItem;
+};
+export type SettingsGetDetailResponse = SettingsGetDetailResponses[keyof SettingsGetDetailResponses];
+export type SettingsUpdateData = {
+    /**
+     * The settings value
+     */
+    body?: unknown;
+    path: {
+        /**
+         * The settigns name
+         */
+        name: string;
+    };
+    query?: never;
+    url: "/settings/{name}";
+};
+export type SettingsUpdateErrors = {
+    /**
+     * Wrong parameter name or value was passed
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Insufficient permissions
+     */
+    403: {
+        message?: string;
+    };
+};
+export type SettingsUpdateError = SettingsUpdateErrors[keyof SettingsUpdateErrors];
+export type SettingsUpdateResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type SettingsUpdateResponse = SettingsUpdateResponses[keyof SettingsUpdateResponses];
+export type StationsListData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/stations";
+};
+export type StationsListErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type StationsListError = StationsListErrors[keyof StationsListErrors];
+export type StationsListResponses = {
+    /**
+     * Success
+     */
+    200: Array<StationItem>;
+};
+export type StationsListResponse = StationsListResponses[keyof StationsListResponses];
+export type StationsCreateData = {
+    body?: StationItemCreate;
+    path?: never;
+    query?: never;
+    url: "/stations";
+};
+export type StationsCreateErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        status?: string;
+        message?: string;
+        data?: {
+            details?: string;
+        };
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type StationsCreateError = StationsCreateErrors[keyof StationsCreateErrors];
+export type StationsCreateResponses = {
+    /**
+     * Success
+     */
+    201: StationItemDetail;
+};
+export type StationsCreateResponse = StationsCreateResponses[keyof StationsCreateResponses];
+export type StationDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * Monitoring station id
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/stations/{id}";
+};
+export type StationDeleteErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Monitoring station not found or insufficient privileges
+     */
+    404: {
+        message?: string;
+    };
+};
+export type StationDeleteError = StationDeleteErrors[keyof StationDeleteErrors];
+export type StationDeleteResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type StationDeleteResponse = StationDeleteResponses[keyof StationDeleteResponses];
+export type StationsGetData = {
+    body?: never;
+    path: {
+        /**
+         * The station ID
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/stations/{id}";
+};
+export type StationsGetErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Not found or not permitted to view
+     */
+    404: {
+        message?: string;
+    };
+};
+export type StationsGetError = StationsGetErrors[keyof StationsGetErrors];
+export type StationsGetResponses = {
+    /**
+     * Success
+     */
+    200: StationItemDetail;
+};
+export type StationsGetResponse = StationsGetResponses[keyof StationsGetResponses];
+export type StationsUpdateData = {
+    body?: StationItemCreate;
+    path: {
+        /**
+         * The ID of the station
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/stations/{id}";
+};
+export type StationsUpdateErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        status?: string;
+        message?: string;
+        data?: {
+            details?: string;
+        };
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type StationsUpdateError = StationsUpdateErrors[keyof StationsUpdateErrors];
+export type StationsUpdateResponses = {
+    /**
+     * Success
+     */
+    201: StationItemDetail;
+};
+export type StationsUpdateResponse = StationsUpdateResponses[keyof StationsUpdateResponses];
+export type StationsDeleteMaintenanceData = {
+    body?: never;
+    path: {
+        /**
+         * The ID of the station
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/stations/maintenance/{id}";
+};
+export type StationsDeleteMaintenanceErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        status?: string;
+        message?: string;
+        data?: {
+            details?: string;
+        };
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type StationsDeleteMaintenanceError = StationsDeleteMaintenanceErrors[keyof StationsDeleteMaintenanceErrors];
+export type StationsDeleteMaintenanceResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type StationsDeleteMaintenanceResponse = StationsDeleteMaintenanceResponses[keyof StationsDeleteMaintenanceResponses];
+export type StationsPutMaintenanceData = {
+    body?: never;
+    path: {
+        /**
+         * The ID of the station
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/stations/maintenance/{id}";
+};
+export type StationsPutMaintenanceErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        status?: string;
+        message?: string;
+        data?: {
+            details?: string;
+        };
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type StationsPutMaintenanceError = StationsPutMaintenanceErrors[keyof StationsPutMaintenanceErrors];
+export type StationsPutMaintenanceResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type StationsPutMaintenanceResponse = StationsPutMaintenanceResponses[keyof StationsPutMaintenanceResponses];
+export type StationsOnpremiseListData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/stations/onpremise";
+};
+export type StationsOnpremiseListErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type StationsOnpremiseListError = StationsOnpremiseListErrors[keyof StationsOnpremiseListErrors];
+export type StationsOnpremiseListResponses = {
+    /**
+     * Success
+     */
+    200: Array<StationItem>;
+};
+export type StationsOnpremiseListResponse = StationsOnpremiseListResponses[keyof StationsOnpremiseListResponses];
+export type StationsOnpremiseConnectedData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/stations/onpremise/connected";
+};
+export type StationsOnpremiseConnectedErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type StationsOnpremiseConnectedError = StationsOnpremiseConnectedErrors[keyof StationsOnpremiseConnectedErrors];
+export type StationsOnpremiseConnectedResponses = {
+    /**
+     * Success
+     */
+    200: Array<StationItem>;
+};
+export type StationsOnpremiseConnectedResponse = StationsOnpremiseConnectedResponses[keyof StationsOnpremiseConnectedResponses];
+export type StationsOnpremiseConnectedAllData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/stations/onpremise/connected/all";
+};
+export type StationsOnpremiseConnectedAllErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type StationsOnpremiseConnectedAllError = StationsOnpremiseConnectedAllErrors[keyof StationsOnpremiseConnectedAllErrors];
+export type StationsOnpremiseConnectedAllResponses = {
+    /**
+     * Success
+     */
+    200: Array<StationItem>;
+};
+export type StationsOnpremiseConnectedAllResponse = StationsOnpremiseConnectedAllResponses[keyof StationsOnpremiseConnectedAllResponses];
+export type StationsLatestData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/stations/latest";
+};
+export type StationsLatestResponses = {
+    /**
+     * Success
+     */
+    200: Array<StationLatest>;
+};
+export type StationsLatestResponse = StationsLatestResponses[keyof StationsLatestResponses];
+export type StationsAgentTypeData = {
+    body?: never;
+    path: {
+        /**
+         * The new agent to use
+         */
+        agent: "ccagent" | "cbot";
+        /**
+         * The ID of the station
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/stations/{agent}/{id}";
+};
+export type StationsAgentTypeErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Not found or not permitted to view
+     */
+    404: {
+        message?: string;
+    };
+};
+export type StationsAgentTypeError = StationsAgentTypeErrors[keyof StationsAgentTypeErrors];
+export type StationsAgentTypeResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type StationsAgentTypeResponse = StationsAgentTypeResponses[keyof StationsAgentTypeResponses];
+export type StationsGetAgentsData = {
+    body?: never;
+    path: {
+        /**
+         * The ID of the station
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/stations/agents/{id}";
+};
+export type StationsGetAgentsErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+    /**
+     * Not found or not permitted to view
+     */
+    404: {
+        message?: string;
+    };
+};
+export type StationsGetAgentsError = StationsGetAgentsErrors[keyof StationsGetAgentsErrors];
+export type StationsGetAgentsResponses = {
+    /**
+     * Success
+     */
+    200: Array<StationAgent>;
+};
+export type StationsGetAgentsResponse = StationsGetAgentsResponses[keyof StationsGetAgentsResponses];
+export type StatisticData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * List of monitors to query. If both 'monitors' and 'folders' are omitted,
+         * query all monitors. Format: Monitor name (string) or monitor ID (integer).
+         */
+        monitor?: Array<string>;
+        /**
+         * List of folders to query. If both 'monitors' and 'folders' are omitted,
+         * query all monitors. Format: Folder name (string) or folder ID (integer).
+         */
+        folder?: Array<string>;
+        /**
+         * List of locations to filter by. Format: Location name (string) or location ID (integer).
+         */
+        location?: Array<string>;
+        /**
+         * Start of interval. Format: ISO 8601 date and time.
+         */
+        from: string;
+        /**
+         * End of interval. Format: ISO 8601 date and time. Default is the current time.
+         */
+        to?: string;
+        /**
+         * Return a time series with a given period between data points. Format: ISO 8601 duration. If omitted, return a single value.
+         */
+        period?: string;
+        /**
+         * Group results by monitor or location.
+         */
+        groupBy?: "monitor" | "location";
+        /**
+         * List of metrics to return. If omitted, return all metrics.
+         */
+        metric?: Array<string>;
+    };
+    url: "/statistic";
+};
+export type StatisticErrors = {
+    /**
+     * Bad request.
+     */
+    400: unknown;
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type StatisticError = StatisticErrors[keyof StatisticErrors];
+export type StatisticResponses = {
+    /**
+     * Success
+     */
+    200: Array<StatisticItem>;
+};
+export type StatisticResponse = StatisticResponses[keyof StatisticResponses];
+export type TagsGetAllData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/tags";
+};
+export type TagsGetAllErrors = {
+    /**
+     * Access to the resource was denied.
+     */
+    403: {
+        message?: string;
+    };
+};
+export type TagsGetAllError = TagsGetAllErrors[keyof TagsGetAllErrors];
+export type TagsGetAllResponses = {
+    /**
+     * Success
+     */
+    200: Array<MonitorTag>;
+};
+export type TagsGetAllResponse = TagsGetAllResponses[keyof TagsGetAllResponses];
+export type TimezonesListData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/timezones";
+};
+export type TimezonesListErrors = {
+    /**
+     * Access to the resource was denied.
+     */
+    403: {
+        message?: string;
+    };
+};
+export type TimezonesListError = TimezonesListErrors[keyof TimezonesListErrors];
+export type TimezonesListResponses = {
+    /**
+     * Success
+     */
+    200: Array<TimezoneItem>;
+};
+export type TimezonesListResponse = TimezonesListResponses[keyof TimezonesListResponses];
+export type UserGetData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/user";
+};
+export type UserGetErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type UserGetError = UserGetErrors[keyof UserGetErrors];
+export type UserGetResponses = {
+    /**
+     * Success
+     */
+    200: User;
+};
+export type UserGetResponse = UserGetResponses[keyof UserGetResponses];
+export type UserSubaccountsGetData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: "/user/subaccounts";
+};
+export type UserSubaccountsGetErrors = {
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type UserSubaccountsGetError = UserSubaccountsGetErrors[keyof UserSubaccountsGetErrors];
+export type UserSubaccountsGetResponses = {
+    /**
+     * Success
+     */
+    200: Array<User>;
+};
+export type UserSubaccountsGetResponse = UserSubaccountsGetResponses[keyof UserSubaccountsGetResponses];
+export type UserSubaccountsPostData = {
+    /**
+     * User data
+     */
+    body: UserCreate;
+    path?: never;
+    query?: never;
+    url: "/user/subaccounts";
+};
+export type UserSubaccountsPostErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type UserSubaccountsPostError = UserSubaccountsPostErrors[keyof UserSubaccountsPostErrors];
+export type UserSubaccountsPostResponses = {
+    /**
+     * Success
+     */
+    201: User;
+};
+export type UserSubaccountsPostResponse = UserSubaccountsPostResponses[keyof UserSubaccountsPostResponses];
+export type UserBlockDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the account to unblock
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/user/block/{id}";
+};
+export type UserBlockDeleteErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type UserBlockDeleteError = UserBlockDeleteErrors[keyof UserBlockDeleteErrors];
+export type UserBlockDeleteResponses = {
+    /**
+     * Success
+     */
+    200: unknown;
+    /**
+     * Not needed - account not blocked
+     */
+    204: void;
+};
+export type UserBlockDeleteResponse = UserBlockDeleteResponses[keyof UserBlockDeleteResponses];
+export type UserBlockPutData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the account to block
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/user/block/{id}";
+};
+export type UserBlockPutErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type UserBlockPutError = UserBlockPutErrors[keyof UserBlockPutErrors];
+export type UserBlockPutResponses = {
+    /**
+     * Success
+     */
+    200: unknown;
+    /**
+     * Not needed - account already blocked
+     */
+    204: void;
+};
+export type UserBlockPutResponse = UserBlockPutResponses[keyof UserBlockPutResponses];
+export type UserLockDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the account to unlock
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/user/lock/{id}";
+};
+export type UserLockDeleteErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type UserLockDeleteError = UserLockDeleteErrors[keyof UserLockDeleteErrors];
+export type UserLockDeleteResponses = {
+    /**
+     * Success
+     */
+    200: unknown;
+    /**
+     * Not needed - account not locked
+     */
+    204: void;
+};
+export type UserLockDeleteResponse = UserLockDeleteResponses[keyof UserLockDeleteResponses];
+export type UserDeleteData = {
+    body?: never;
+    path: {
+        /**
+         * ID of the account to remove
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/user/{id}";
+};
+export type UserDeleteErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type UserDeleteError = UserDeleteErrors[keyof UserDeleteErrors];
+export type UserDeleteResponses = {
+    /**
+     * Success
+     */
+    204: void;
+};
+export type UserDeleteResponse = UserDeleteResponses[keyof UserDeleteResponses];
+export type UserPutData = {
+    /**
+     * User data
+     */
+    body: UserCreate;
+    path: {
+        /**
+         * The ID of the account
+         */
+        id: number;
+    };
+    query?: never;
+    url: "/user/{id}";
+};
+export type UserPutErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        message?: string;
+    };
+    /**
+     * Not permitted to access
+     */
+    403: Forbidden;
+};
+export type UserPutError = UserPutErrors[keyof UserPutErrors];
+export type UserPutResponses = {
+    /**
+     * Success
+     */
+    201: User;
+};
+export type UserPutResponse = UserPutResponses[keyof UserPutResponses];
+//# sourceMappingURL=types.gen.d.ts.map