@dx-do/client 5.2.48 → 5.2.50

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

@@ -0,0 +1,4546 @@
+export declare const ApiTokenNotFoundSchema: {
+    readonly properties: {
+        readonly status: {
+            readonly type: "string";
+            readonly example: "Not Found";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly example: "Not found";
+        };
+    };
+    readonly type: "object";
+};
+export declare const ApiTokenSchema: {
+    readonly properties: {
+        readonly id: {
+            readonly type: "integer";
+            readonly example: 1;
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly example: "Token name";
+        };
+        readonly valid_until: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly example: "2020-01-08T11:05:21+01:00";
+            readonly nullable: true;
+        };
+        readonly created: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly example: "2020-01-01T11:05:21+01:00";
+        };
+    };
+    readonly type: "object";
+};
+export declare const ContactAuthSchema: {
+    readonly required: readonly ["type"];
+    readonly properties: {
+        readonly type: {
+            readonly description: "The supported authentication method.";
+            readonly type: "string";
+            readonly enum: readonly ["basic", "bearer"];
+        };
+        readonly user: {
+            readonly description: "User name if the authentication type requires it";
+            readonly type: "string";
+            readonly example: "me@example.com";
+            readonly nullable: true;
+        };
+        readonly secret: {
+            readonly description: "The authentication secret or token. This value is not sent in GET requests, it can only be created or updated.";
+            readonly type: "string";
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const ContactCatalogueSchema: {
+    readonly required: readonly ["folders", "contacts"];
+    readonly properties: {
+        readonly folders: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/ResourceGroupItemWithPermission";
+            };
+        };
+        readonly contacts: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/ContactItem";
+            };
+        };
+    };
+    readonly type: "object";
+};
+export declare const ContactItemSchema: {
+    readonly required: readonly ["id", "name", "type", "status", "default"];
+    readonly properties: {
+        readonly id: {
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly example: 1;
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly example: "Contact name";
+        };
+        readonly type: {
+            readonly description: "Group contacts are containers for standard contacts - members.";
+            readonly type: "string";
+            readonly enum: readonly ["email", "sms", "phone", "action", "rss", "group"];
+        };
+        readonly address: {
+            readonly description: "Not used for group contact type";
+            readonly type: "string";
+            readonly example: "me@example.com";
+        };
+        readonly status: {
+            readonly description: "0=invalid,1=unconfirmed,2=active,3=blocked,4=inactive";
+            readonly type: "integer";
+            readonly enum: readonly [0, 1, 2, 3, 4];
+            readonly example: 2;
+        };
+        readonly default: {
+            readonly type: "boolean";
+        };
+        readonly ownerId: {
+            readonly type: "integer";
+            readonly example: 6;
+        };
+        readonly folderId: {
+            readonly type: "integer";
+            readonly example: null;
+            readonly nullable: true;
+        };
+        readonly workingFrom: {
+            readonly description: "Time HH:ss in contact's time zone; workingFrom and workingTo represent time interval when the contact can be alerted.";
+            readonly type: "string";
+            readonly example: "00:00";
+        };
+        readonly workingTo: {
+            readonly description: "Time HH:ss in contact's time zone; workingFrom and workingTo represent time interval when the contact can be alerted.";
+            readonly type: "string";
+            readonly example: "23:59";
+        };
+        readonly workingDays: {
+            readonly description: "Days when the contact can be used for alerting. 0 = Monday ... 6 = Sunday";
+            readonly type: "array";
+            readonly items: {
+                readonly type: "integer";
+            };
+            readonly example: readonly [0, 1, 2, 3, 4, 5, 6];
+        };
+        readonly timezone: {
+            readonly description: string;
+            readonly type: "string";
+            readonly example: "America/Los_Angeles";
+            readonly nullable: true;
+        };
+        readonly members: {
+            readonly description: string;
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/ContactGroupMemberItem";
+            };
+        };
+        readonly auth: {
+            readonly description: "Authentication details. Authentication can be added for the action url contact type only.";
+            readonly oneOf: readonly [{
+                readonly $ref: "#/components/schemas/ContactAuth";
+            }, {
+                readonly type: "object";
+                readonly nullable: true;
+            }];
+        };
+        readonly specification: {
+            readonly description: "Special flags specific for the contact type. Currently, only action contact type supports specifications.\n               Json changes the content type for the action url to send message as a json instead of standard application/x-www-form-urlencoded.\n               gchat changes both content type and message form to send message to a Google chat webhook.";
+            readonly type: "string";
+            readonly enum: readonly ["json", "gchat"];
+            readonly example: null;
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const ContactItemCreateSchema: {
+    readonly required: readonly ["name", "type", "address"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/ContactItemUpdate";
+    }, {
+        readonly properties: {
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["email", "sms", "phone", "action", "rss", "group"];
+            };
+        };
+    }];
+};
+export declare const ContactItemUpdateSchema: {
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly example: "Contact name";
+            readonly nullable: true;
+        };
+        readonly address: {
+            readonly description: "Address of the contact. The scheme depends on the contact type.";
+            readonly type: "string";
+            readonly example: "me@example.com";
+            readonly nullable: true;
+        };
+        readonly default: {
+            readonly description: "Is this contact the default account contact? Only one contact can be default.";
+            readonly type: "boolean";
+            readonly nullable: true;
+        };
+        readonly folderId: {
+            readonly description: "ID of the folder this contact should be assigned to";
+            readonly type: "integer";
+            readonly example: null;
+            readonly nullable: true;
+        };
+        readonly workingFrom: {
+            readonly description: string;
+            readonly type: "string";
+            readonly example: "00:00";
+        };
+        readonly workingTo: {
+            readonly description: string;
+            readonly type: "string";
+            readonly example: "23:59";
+            readonly nullable: true;
+        };
+        readonly workingDays: {
+            readonly description: "Days when the contact can be alerted. Do not use for contact groups.";
+            readonly type: "array";
+            readonly items: {
+                readonly type: "integer";
+            };
+            readonly example: readonly [0, 1, 2, 3, 4, 5, 6];
+            readonly nullable: true;
+        };
+        readonly timezone: {
+            readonly description: string;
+            readonly type: "string";
+            readonly example: "America/Los_Angeles";
+            readonly nullable: true;
+        };
+        readonly members: {
+            readonly description: string;
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/ContactGroupMemberCreate";
+            };
+            readonly nullable: true;
+        };
+        readonly auth: {
+            readonly description: "Authentication details. Authentication can be added for the action url contact type only.";
+            readonly oneOf: readonly [{
+                readonly $ref: "#/components/schemas/ContactAuth";
+            }, {
+                readonly type: "object";
+                readonly nullable: true;
+            }];
+        };
+        readonly specification: {
+            readonly description: "Special flags specific for the contact type. Currently, only action contact type supports specifications.\n               Json changes the content type for the action url to send message as a json instead of standard application/x-www-form-urlencoded.\n               gchat changes both content type and message form to send message to a Google chat webhook.";
+            readonly type: "string";
+            readonly enum: readonly ["json", "gchat"];
+            readonly example: null;
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const ContactGroupMemberItemSchema: {
+    readonly required: readonly ["contactId", "groupId", "alertAfter"];
+    readonly properties: {
+        readonly contactId: {
+            readonly description: "ID of the contact (member of the group)";
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly example: 1;
+        };
+        readonly groupId: {
+            readonly description: "ID of the group (contact of type group) the contact is member of";
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly example: 1;
+        };
+        readonly alertAfter: {
+            readonly description: "Send alert after (alertAfter-1) errors. 0 means alert immediately (after 1 error), 1 after 2 errors, etc.";
+            readonly type: "integer";
+            readonly enum: readonly [0, 1, 2, 3, 4];
+            readonly example: 1;
+        };
+    };
+    readonly type: "object";
+};
+export declare const ContactGroupMemberCreateSchema: {
+    readonly required: readonly ["contactId", "alertAfter"];
+    readonly properties: {
+        readonly contactId: {
+            readonly description: "ID of the contact (member of the group)";
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly example: 1;
+        };
+        readonly alertAfter: {
+            readonly description: "Send alert after (alertAfter-1) errors. 0 means alert immediately (after 1 error), 1 after 2 errors, etc.";
+            readonly type: "integer";
+            readonly enum: readonly [0, 1, 2, 3, 4];
+            readonly example: 1;
+        };
+    };
+    readonly type: "object";
+};
+export declare const MaintenanceCatalogueSchema: {
+    readonly required: readonly ["folders", "maintenances"];
+    readonly properties: {
+        readonly folders: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/ResourceGroupItemWithPermission";
+            };
+        };
+        readonly maintenances: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/MaintenanceItem";
+            };
+        };
+    };
+    readonly type: "object";
+};
+export declare const MaintenanceItemSchema: {
+    readonly required: readonly ["id", "name", "timezone", "ruleCount"];
+    readonly properties: {
+        readonly id: {
+            readonly type: "integer";
+            readonly example: 1;
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly example: "My Maintenance Window";
+        };
+        readonly timezone: {
+            readonly type: "string";
+            readonly example: "GMT";
+        };
+        readonly ruleCount: {
+            readonly type: "integer";
+            readonly example: 5;
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly example: "Maintenance window description";
+        };
+        readonly persistent: {
+            readonly type: "boolean";
+        };
+        readonly windows: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/MaintenanceWindowItem";
+            };
+        };
+        readonly permission: {
+            readonly $ref: "#/components/schemas/PermissionItem";
+        };
+        readonly ownerId: {
+            readonly type: "integer";
+            readonly example: 1;
+        };
+        readonly folderId: {
+            readonly type: "integer";
+            readonly example: 5;
+            readonly nullable: true;
+        };
+        readonly monitorIds: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "integer";
+            };
+            readonly example: readonly [5, 6];
+        };
+        readonly immediateForRuleId: {
+            readonly type: "integer";
+            readonly example: 3;
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const MaintenanceItemCreateSchema: {
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly example: "My Maintenance Window";
+        };
+        readonly timezone: {
+            readonly type: "string";
+            readonly example: "GMT";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly example: "Maintenance window description";
+        };
+        readonly persistent: {
+            readonly type: "boolean";
+            readonly example: false;
+        };
+        readonly windows: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/WindowItemCreate";
+            };
+        };
+        readonly folderId: {
+            readonly type: "integer";
+            readonly example: 5;
+            readonly nullable: true;
+        };
+        readonly monitorIds: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "integer";
+            };
+            readonly example: readonly [1, 6, 8];
+        };
+    };
+    readonly type: "object";
+};
+export declare const MaintenanceItemImmediateCreateSchema: {
+    readonly required: readonly ["duration", "monitorIds"];
+    readonly properties: {
+        readonly from: {
+            readonly description: string;
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly example: "2021-12-01 01:00:00+00";
+            readonly nullable: true;
+        };
+        readonly duration: {
+            readonly description: "Duration of the immediate maintenance window, format [H][H]H:MM";
+            readonly type: "string";
+            readonly example: "1:30";
+        };
+        readonly monitorIds: {
+            readonly description: "Ids of monitors this maintenance should be assigned to. You need update permission for these monitors";
+            readonly type: "array";
+            readonly items: {
+                readonly type: "integer";
+            };
+            readonly example: readonly [1, 6, 8];
+        };
+    };
+    readonly type: "object";
+};
+export declare const MaintenanceWindowItemSchema: {
+    readonly required: readonly ["type", "status", "from"];
+    readonly properties: {
+        readonly id: {
+            readonly type: "integer";
+            readonly example: 5;
+            readonly nullable: true;
+        };
+        readonly type: {
+            readonly type: "string";
+            readonly enum: readonly ["fixed", "daily", "weekly", "monthly"];
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["active", "waiting", "passed"];
+        };
+        readonly from: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly example: "2020-02-02T00:00:00";
+        };
+        readonly to: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly example: "2025-05-05T23:59:59";
+        };
+        readonly effectiveTo: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly example: "2025-05-05T23:59:59";
+        };
+        readonly repeat: {
+            readonly description: "For repeating time windows means repeat every N (days, weeks, months).";
+            readonly type: "integer";
+            readonly example: 1;
+            readonly nullable: true;
+        };
+        readonly dow: {
+            readonly description: "For weekly recurring time window: 0 - Monday, 6 - Sunday";
+            readonly type: "array";
+            readonly items: {
+                readonly type: "integer";
+            };
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const WindowItemCreateSchema: {
+    readonly properties: {
+        readonly type: {
+            readonly description: "This parameter is always required";
+            readonly type: "string";
+            readonly enum: readonly ["fixed", "daily", "weekly", "montly"];
+        };
+        readonly from: {
+            readonly description: string;
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly example: "2020-01-01T00:00:00";
+        };
+        readonly to: {
+            readonly description: "End time of this window applicability. Required for these types: fixed";
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly example: "2020-12-31T23:59:59";
+        };
+        readonly repeat: {
+            readonly description: "For repeating time windows means repeat every N (days, weeks, months). Required for all but fixed type.";
+            readonly type: "integer";
+            readonly example: 1;
+            readonly nullable: true;
+        };
+        readonly endTime: {
+            readonly description: string;
+            readonly type: "string";
+            readonly example: "00:10";
+            readonly nullable: true;
+        };
+        readonly dow: {
+            readonly description: "For weekly recurring time window applicable days: 0 - Monday, 6 - Sunday.";
+            readonly type: "array";
+            readonly items: {
+                readonly type: "integer";
+            };
+            readonly example: readonly [2, 4, 6];
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const MessageItemSchema: {
+    readonly required: readonly ["id", "entered", "type", "status"];
+    readonly properties: {
+        readonly id: {
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly example: 1;
+        };
+        readonly entered: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly sent: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly nullable: true;
+        };
+        readonly monitorId: {
+            readonly description: "Monitor ID";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly contactId: {
+            readonly description: "Contact ID";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly type: {
+            readonly description: "Contact type";
+            readonly type: "string";
+            readonly enum: readonly ["email", "sms", "phone", "action", "rss"];
+        };
+        readonly address: {
+            readonly description: "Monitor ID";
+            readonly type: "string";
+        };
+        readonly status: {
+            readonly description: "Message delivery status";
+            readonly type: "string";
+            readonly enum: readonly ["deleted", "queued", "gateway", "provider", "device", "accepted", "queued-no-fallback", "undeliverable", "suppressed"];
+        };
+        readonly eventId: {
+            readonly description: "Monitor log event uuid";
+            readonly type: "string";
+            readonly nullable: true;
+        };
+        readonly message: {
+            readonly description: "Text of the message";
+            readonly type: "string";
+        };
+    };
+    readonly type: "object";
+};
+export declare const MonitorsPageSchema: {
+    readonly description: "This schema is used to return a page from the list of monitors with additional pagination information";
+    readonly properties: {
+        readonly monitors: {
+            readonly description: "List of monitors.";
+            readonly type: "array";
+            readonly items: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/components/schemas/Browser";
+                }, {
+                    readonly $ref: "#/components/schemas/Connect";
+                }, {
+                    readonly $ref: "#/components/schemas/Dns";
+                }, {
+                    readonly $ref: "#/components/schemas/Dnsa";
+                }, {
+                    readonly $ref: "#/components/schemas/Dnsns";
+                }, {
+                    readonly $ref: "#/components/schemas/Domain";
+                }, {
+                    readonly $ref: "#/components/schemas/Ftp";
+                }, {
+                    readonly $ref: "#/components/schemas/Ftps";
+                }, {
+                    readonly $ref: "#/components/schemas/Http";
+                }, {
+                    readonly $ref: "#/components/schemas/Https";
+                }, {
+                    readonly $ref: "#/components/schemas/Imap";
+                }, {
+                    readonly $ref: "#/components/schemas/Ldap";
+                }, {
+                    readonly $ref: "#/components/schemas/Ping";
+                }, {
+                    readonly $ref: "#/components/schemas/Plugin";
+                }, {
+                    readonly $ref: "#/components/schemas/Pop3";
+                }, {
+                    readonly $ref: "#/components/schemas/Scp";
+                }, {
+                    readonly $ref: "#/components/schemas/Script";
+                }, {
+                    readonly $ref: "#/components/schemas/Sftp";
+                }, {
+                    readonly $ref: "#/components/schemas/Sip";
+                }, {
+                    readonly $ref: "#/components/schemas/Smtp";
+                }, {
+                    readonly $ref: "#/components/schemas/Telnet";
+                }, {
+                    readonly $ref: "#/components/schemas/Webdriver";
+                }];
+            };
+        };
+        readonly numMonitors: {
+            readonly description: "Number of monitors returned in the monitors array.";
+            readonly type: "integer";
+        };
+        readonly numFolders: {
+            readonly description: "Number of unique folders returned the returned monitors belong to. These folders are also attached in the folders array.";
+            readonly type: "integer";
+        };
+        readonly numNotInFolder: {
+            readonly description: "Number of monitors out of folder in the response";
+            readonly type: "integer";
+        };
+        readonly totalMonitors: {
+            readonly description: "Total number of monitors that would be returned if no limit/offset restriction is applied";
+            readonly type: "integer";
+        };
+        readonly totalFolders: {
+            readonly description: "Total number of folders that would be returned if no limit/offset restriction is applied";
+            readonly type: "integer";
+        };
+        readonly totalNotInFolder: {
+            readonly description: "Total number of monitors out of folder if no limit/offset restriction is applied";
+            readonly type: "integer";
+        };
+        readonly folders: {
+            readonly $ref: "#/components/schemas/FolderItem";
+        };
+    };
+    readonly type: "object";
+};
+export declare const OauthClientCredentialsNotFoundSchema: {
+    readonly properties: {
+        readonly status: {
+            readonly type: "string";
+            readonly example: "Not Found";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly example: "Not found";
+        };
+    };
+    readonly type: "object";
+};
+export declare const OauthClientCredentialsItemSchema: {
+    readonly properties: {
+        readonly id: {
+            readonly type: "integer";
+            readonly example: 1;
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly example: "My Credentials";
+        };
+        readonly client_id: {
+            readonly type: "string";
+            readonly example: "Y0AOiWAlCcUTP9xoi8NERy95Fy0ZQjKyZ6bVcQYs0Aw=";
+        };
+        readonly valid_until: {
+            readonly type: "string";
+            readonly example: "2027-01-01T00:00:00+01:00";
+            readonly nullable: true;
+        };
+        readonly access_token_validity: {
+            readonly type: "integer";
+            readonly example: 3600;
+            readonly nullable: true;
+        };
+        readonly refresh_token_validity: {
+            readonly type: "integer";
+            readonly example: 604800;
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const OauthTokenSchema: {
+    readonly properties: {
+        readonly id: {
+            readonly type: "integer";
+            readonly example: 1;
+        };
+        readonly clientId: {
+            readonly description: "Client ID this token is assigned to.";
+            readonly type: "integer";
+            readonly example: 10;
+        };
+        readonly expires: {
+            readonly description: "Date and time when the token expires";
+            readonly type: "string";
+            readonly example: "2022-12-26T00:00:00+00";
+        };
+    };
+    readonly type: "object";
+};
+export declare const PermissionItemSchema: {
+    readonly required: readonly ["type", "level"];
+    readonly properties: {
+        readonly type: {
+            readonly type: "string";
+            readonly example: "resource-group-contact";
+        };
+        readonly level: {
+            readonly type: "string";
+            readonly example: "create-delete";
+        };
+    };
+    readonly type: "object";
+};
+export declare const ResourceGroupItemSchema: {
+    readonly properties: {
+        readonly id: {
+            readonly type: "integer";
+            readonly example: 1;
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly example: "Alert contact dir";
+        };
+        readonly ownerId: {
+            readonly type: "integer";
+            readonly example: 1;
+        };
+    };
+    readonly type: "object";
+};
+export declare const ResourceGroupItemWithPermissionSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/ResourceGroupItem";
+    }, {
+        readonly properties: {
+            readonly resourceCount: {
+                readonly type: "integer";
+                readonly example: 5;
+            };
+            readonly permission: {
+                readonly $ref: "#/components/schemas/PermissionItem";
+            };
+        };
+    }];
+};
+export declare const BulkResponseMetadataSchema: {
+    readonly properties: {
+        readonly success: {
+            readonly description: "A bulk response containing multiple sub-responses for bulk operations";
+            readonly type: "integer";
+            readonly example: 10;
+        };
+        readonly redirect: {
+            readonly type: "integer";
+            readonly example: 0;
+        };
+        readonly client_errors: {
+            readonly type: "integer";
+            readonly example: 2;
+        };
+        readonly server_errors: {
+            readonly type: "integer";
+            readonly example: 0;
+        };
+    };
+    readonly type: "object";
+};
+export declare const BulkResponseSchema: {
+    readonly properties: {
+        readonly metadata: {
+            readonly $ref: "#/components/schemas/BulkResponseMetadata";
+        };
+        readonly responses: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/BulkResponsePart";
+            };
+        };
+    };
+    readonly type: "object";
+};
+export declare const BulkResponsePartSchema: {
+    readonly description: "One part of a multi-part response\n\nWhen performing bulk operations, each item has its own response\nThis class represents response for one item\n\nIt is merged in BulkResponse";
+    readonly required: readonly ["id", "status"];
+    readonly properties: {
+        readonly id: {
+            readonly description: "ID of the entity this response is connected to (user ID, folder ID...)";
+            readonly example: 123456;
+            readonly oneOf: readonly [{
+                readonly type: "string";
+            }, {
+                readonly type: "integer";
+            }];
+        };
+        readonly status: {
+            readonly description: "This property is renamed in BulkResponse::getCompleteResponse()";
+            readonly type: "integer";
+            readonly example: 200;
+        };
+        readonly resource: {
+            readonly description: "This property is renamed in BulkResponse::getCompleteResponse()";
+            readonly type: "object";
+            readonly example: {
+                readonly foo: "resource data";
+            };
+        };
+        readonly message: {
+            readonly description: "The subresponse HTTP message";
+            readonly type: "string";
+            readonly example: "OK";
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const FolderItemSchema: {
+    readonly required: readonly ["id", "monitorCount", "name", "isActive", "notifyOn"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/FolderRequestItem";
+    }, {
+        readonly properties: {
+            readonly id: {
+                readonly type: "integer";
+                readonly format: "int64";
+                readonly example: 1;
+            };
+            readonly monitorCount: {
+                readonly type: "integer";
+                readonly example: 1;
+            };
+            readonly permission: {
+                readonly $ref: "#/components/schemas/PermissionItem";
+            };
+            readonly specificPermission: {
+                readonly $ref: "#/components/schemas/PermissionItem";
+            };
+            readonly ownerId: {
+                readonly type: "integer";
+                readonly example: 1;
+            };
+        };
+    }];
+};
+export declare const FolderRequestItemSchema: {
+    readonly required: readonly ["name", "isActive", "notifyOn"];
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly example: "Folder name";
+        };
+        readonly isActive: {
+            readonly type: "boolean";
+        };
+        readonly notifyOn: {
+            readonly type: "boolean";
+        };
+    };
+    readonly type: "object";
+};
+export declare const ForbiddenSchema: {
+    readonly properties: {
+        readonly status: {
+            readonly type: "string";
+            readonly example: "Forbidden";
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly example: "Access to the resource was denied.";
+        };
+    };
+    readonly type: "object";
+};
+export declare const SettingsItemSchema: {
+    readonly required: readonly ["name", "value"];
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly example: "accessible";
+        };
+        readonly type: {
+            readonly type: "string";
+            readonly default: "bool";
+            readonly enum: readonly ["bool", "integer", "string", "secret", "integers"];
+        };
+        readonly value: {
+            readonly type: "array";
+            readonly items: {};
+            readonly example: "true";
+            readonly oneOf: readonly [{
+                readonly type: "string";
+            }, {
+                readonly type: "integer";
+            }, {
+                readonly type: "boolean";
+            }, {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "integer";
+                };
+            }];
+        };
+    };
+    readonly type: "object";
+};
+export declare const StationAgentSchema: {
+    readonly properties: {
+        readonly type: {
+            readonly description: "Monitor type";
+            readonly type: "string";
+            readonly example: "https";
+        };
+        readonly agent: {
+            readonly description: "Agent name";
+            readonly type: "string";
+            readonly example: "ccagent";
+        };
+    };
+    readonly type: "object";
+};
+export declare const StationAgentsSchema: {
+    readonly properties: {
+        readonly ccagent: {
+            readonly description: "Number of ccagents";
+            readonly type: "integer";
+            readonly example: "10";
+            readonly nullable: true;
+        };
+        readonly cbot: {
+            readonly description: "Number of cbot agents";
+            readonly type: "integer";
+            readonly example: "10";
+            readonly nullable: true;
+        };
+        readonly fpm: {
+            readonly description: "Number of full-page agents";
+            readonly type: "integer";
+            readonly example: "2";
+            readonly nullable: true;
+        };
+        readonly jmeter2: {
+            readonly description: "Number of jmeter2 agents";
+            readonly type: "integer";
+            readonly example: "2";
+            readonly nullable: true;
+        };
+        readonly jmeter4: {
+            readonly description: "Number of jmeter4 agents";
+            readonly type: "integer";
+            readonly example: "2";
+            readonly nullable: true;
+        };
+        readonly jmeter5: {
+            readonly description: "Number of jmeter5 agents";
+            readonly type: "integer";
+            readonly example: "2";
+            readonly nullable: true;
+        };
+        readonly webdriver: {
+            readonly description: "Number of webdriver agents";
+            readonly type: "integer";
+            readonly example: "2";
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const StationItemSchema: {
+    readonly properties: {
+        readonly id: {
+            readonly type: "integer";
+            readonly example: 1;
+        };
+        readonly alias: {
+            readonly description: "The unique host name of this monitoring station";
+            readonly type: "string";
+            readonly example: "hubud01.example.com";
+        };
+        readonly locationId: {
+            readonly description: "The location ID this station belongs to";
+            readonly type: "integer";
+            readonly example: "1";
+        };
+        readonly isPublic: {
+            readonly description: "True if the monitoring station is public.";
+            readonly type: "boolean";
+        };
+        readonly ownerId: {
+            readonly description: "ID of the monitoring station owner. Public stations have no owners.";
+            readonly type: "integer";
+            readonly example: 6;
+            readonly nullable: true;
+        };
+        readonly locode: {
+            readonly description: "The short code assigned during installation - deprecated";
+            readonly type: "string";
+            readonly example: "hubud01";
+        };
+        readonly status: {
+            readonly description: string;
+            readonly type: "integer";
+            readonly enum: readonly [1, 2, 3, 4, 3, 5, 6];
+        };
+        readonly host: {
+            readonly description: "The IP address of this monitoring station";
+            readonly type: "string";
+            readonly example: "1.2.3.4";
+            readonly nullable: true;
+        };
+        readonly city: {
+            readonly type: "string";
+            readonly example: "Madrid";
+        };
+        readonly latitude: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 40.400002;
+        };
+        readonly longitude: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: -3.683;
+        };
+        readonly weight: {
+            readonly description: "Weight of the station in the location.";
+            readonly type: "integer";
+            readonly example: "1";
+        };
+        readonly osVersion: {
+            readonly description: "The version of the OS";
+            readonly type: "string";
+            readonly example: "CentOS 8";
+        };
+        readonly version: {
+            readonly description: "The version of the ASM station installed";
+            readonly type: "string";
+            readonly example: "10.4.0";
+        };
+        readonly description: {
+            readonly description: "Custom text description.";
+            readonly type: "string";
+        };
+        readonly engine: {
+            readonly description: "Engine used for orchestration - kubernetes, docker-composer, etc.";
+            readonly type: "string";
+            readonly example: "kubernetes";
+        };
+        readonly useCcagent: {
+            readonly description: "Use ccagent instead of cbot";
+            readonly type: "boolean";
+            readonly example: "false";
+        };
+    };
+    readonly type: "object";
+};
+export declare const StationItemCreateSchema: {
+    readonly properties: {
+        readonly alias: {
+            readonly description: "The host name of this monitoring station";
+            readonly type: "string";
+            readonly example: "hubud01.example.com";
+        };
+        readonly locationId: {
+            readonly description: "The location ID this station belongs to";
+            readonly type: "integer";
+            readonly example: "1";
+        };
+        readonly status: {
+            readonly description: "Status of the monitoring station: 1 - planned, 2 - active, 3 - in maintenance, 4 - blocked.";
+            readonly type: "integer";
+            readonly enum: readonly [1, 2, 3, 4, 3];
+        };
+        readonly host: {
+            readonly description: "The IP address of this monitoring station";
+            readonly type: "string";
+            readonly example: "1.2.3.4";
+            readonly nullable: true;
+        };
+        readonly city: {
+            readonly type: "string";
+            readonly example: "Madrid";
+        };
+        readonly latitude: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 40.400002;
+        };
+        readonly longitude: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: -3.683;
+        };
+        readonly weight: {
+            readonly description: "Weight of the station in the location.";
+            readonly type: "integer";
+            readonly example: "1";
+        };
+        readonly osVersion: {
+            readonly description: "The version of the OS";
+            readonly type: "string";
+            readonly example: "CentOS 8";
+        };
+        readonly version: {
+            readonly description: "The version of the ASM station installed";
+            readonly type: "string";
+            readonly example: "10.4.0";
+        };
+        readonly secret: {
+            readonly description: string;
+            readonly type: "string";
+        };
+        readonly description: {
+            readonly description: "Custom text description.";
+            readonly type: "string";
+        };
+        readonly installerMetadata: {
+            readonly description: "Metadata for the installer (json encoded). Internal use only.";
+            readonly type: "string";
+            readonly example: "{'a':1}";
+        };
+        readonly engine: {
+            readonly description: "Engine used for orchestration - kubernetes, docker-composer, etc.";
+            readonly type: "string";
+            readonly example: "kubernetes";
+        };
+        readonly useCcagent: {
+            readonly description: "Use ccagent instead of cbot";
+            readonly type: "boolean";
+            readonly example: "false";
+        };
+        readonly agents: {
+            readonly oneOf: readonly [{
+                readonly $ref: "#/components/schemas/StationAgents";
+            }, {
+                readonly type: "object";
+                readonly nullable: true;
+            }];
+        };
+    };
+    readonly type: "object";
+};
+export declare const StationItemDetailSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/StationItem";
+    }, {
+        readonly properties: {
+            readonly tunnelId: {
+                readonly description: "Tunnel ID.";
+                readonly type: "string";
+            };
+            readonly token: {
+                readonly description: string;
+                readonly type: "string";
+                readonly example: "abc-de-5e7";
+                readonly nullable: true;
+            };
+            readonly installerMetadata: {
+                readonly description: "Metadata for the installer (json encoded).";
+                readonly type: "string";
+            };
+            readonly agents: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/components/schemas/StationAgents";
+                }, {
+                    readonly type: "object";
+                    readonly nullable: true;
+                }];
+            };
+        };
+    }];
+};
+export declare const StationLatestSchema: {
+    readonly properties: {
+        readonly version: {
+            readonly description: "The current version of the station";
+            readonly type: "string";
+            readonly example: "2022.11";
+        };
+        readonly installer: {
+            readonly description: "The current version of the installer";
+            readonly type: "string";
+            readonly example: "2022.8";
+        };
+    };
+    readonly type: "object";
+};
+export declare const TimezoneItemSchema: {
+    readonly properties: {
+        readonly name: {
+            readonly description: "The name of this timezone";
+            readonly type: "string";
+            readonly example: "Asia/Hong_Kong";
+        };
+        readonly offset: {
+            readonly description: "[+-]HH:mm offset to UTC";
+            readonly type: "string";
+            readonly example: "+08:00";
+        };
+        readonly hasDst: {
+            readonly description: "True if the timezone observes/observed DST for the year of the call";
+            readonly type: "boolean";
+        };
+        readonly isDst: {
+            readonly description: "True if the timezone is in DST at the time of the call";
+            readonly type: "boolean";
+        };
+    };
+    readonly type: "object";
+};
+export declare const UserSchema: {
+    readonly description: "Class User";
+    readonly required: readonly ["id"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/UserCreate";
+    }, {
+        readonly properties: {
+            readonly id: {
+                readonly type: "integer";
+                readonly example: 1;
+            };
+            readonly lastseen: {
+                readonly description: "Date time of last login";
+                readonly type: "string";
+                readonly format: "date-time";
+            };
+            readonly status: {
+                readonly description: "Status (read only)\n1 ... unconfirmed\n2 ... active\n3 ... blocked\n4 ... unsubscribing\n5 ... on hold";
+                readonly type: "integer";
+                readonly example: 2;
+            };
+            readonly roles: {
+                readonly description: "List of custom roles the user is member of (read only)";
+                readonly type: "array";
+                readonly items: {
+                    readonly $ref: "#/components/schemas/Role";
+                };
+            };
+            readonly locked: {
+                readonly description: "Is account locked?";
+                readonly type: "boolean";
+                readonly example: false;
+            };
+            readonly canLoginAsParent: {
+                readonly description: "True/false if user can login as parent account (owner), null if not evaulated";
+                readonly type: "boolean";
+                readonly example: null;
+                readonly nullable: true;
+            };
+        };
+    }];
+};
+export declare const UserCreateSchema: {
+    readonly description: "Class UserCreate";
+    readonly required: readonly ["email", "name"];
+    readonly properties: {
+        readonly email: {
+            readonly type: "string";
+            readonly maxLength: 80;
+            readonly example: "john.doe@example.com";
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly maxLength: 60;
+            readonly example: "John Doe";
+        };
+        readonly company: {
+            readonly type: "string";
+            readonly maxLength: 60;
+            readonly example: "My Company Ltd.";
+        };
+        readonly website: {
+            readonly type: "string";
+            readonly maxLength: 255;
+            readonly example: "https://www.example.com";
+        };
+        readonly address: {
+            readonly type: "string";
+            readonly maxLength: 60;
+            readonly example: "2584 Canis Heights Drive";
+        };
+        readonly city: {
+            readonly type: "string";
+            readonly maxLength: 40;
+            readonly example: "Los Angeles";
+        };
+        readonly zip: {
+            readonly type: "string";
+            readonly maxLength: 10;
+            readonly example: "90071";
+        };
+        readonly state: {
+            readonly type: "string";
+            readonly maxLength: 40;
+            readonly example: "California";
+        };
+        readonly country: {
+            readonly description: "ISO 3166-1 alpha-2 country code";
+            readonly type: "string";
+            readonly maxLength: 2;
+            readonly minLength: 2;
+            readonly example: "us";
+        };
+        readonly lang: {
+            readonly type: "string";
+            readonly example: "en";
+        };
+        readonly timezone: {
+            readonly type: "string";
+            readonly example: "America/Los_Angeles";
+        };
+    };
+    readonly type: "object";
+};
+export declare const RoleSchema: {
+    readonly required: readonly ["name"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/RoleCreate";
+    }, {
+        readonly properties: {
+            readonly id: {
+                readonly description: "Unique role ID";
+                readonly type: "integer";
+                readonly example: 995;
+            };
+            readonly name: {
+                readonly description: "Unique role name. Use role ID instead, this value is deprecated.";
+                readonly type: "string";
+                readonly example: "custom_123_995";
+            };
+        };
+    }];
+};
+export declare const RoleCreateSchema: {
+    readonly required: readonly ["description"];
+    readonly properties: {
+        readonly description: {
+            readonly type: "string";
+            readonly example: "My role description";
+        };
+    };
+    readonly type: "object";
+};
+export declare const LocationSchema: {
+    readonly description: "Class Location";
+    readonly required: readonly ["id", "name", "parent"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/LocationDraft";
+    }, {
+        readonly properties: {
+            readonly id: {
+                readonly description: "Unique ID of the location.";
+                readonly type: "integer";
+                readonly example: 1;
+            };
+            readonly parent: {
+                readonly description: "Parent location ID.";
+                readonly type: "integer";
+                readonly example: 2;
+                readonly nullable: true;
+            };
+            readonly country: {
+                readonly description: "Iso code of the country this location belongs to or null.";
+                readonly type: "string";
+                readonly example: "us";
+            };
+            readonly isPrivate: {
+                readonly description: "If true, it is a private (on-premise) location. Otherwise it is a public one.";
+                readonly type: "boolean";
+            };
+            readonly canCreateLocations: {
+                readonly description: "Can the user create nested locations to this location?";
+                readonly type: "boolean";
+            };
+            readonly canCreateStations: {
+                readonly description: "Can the user create private monitoring stations in this location?";
+                readonly type: "boolean";
+            };
+            readonly region: {
+                readonly description: "Location region details";
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/components/schemas/Region";
+                }, {
+                    readonly type: "object";
+                    readonly nullable: true;
+                }];
+            };
+        };
+    }];
+};
+export declare const LocationDraftSchema: {
+    readonly description: "Class LocationDraft";
+    readonly required: readonly ["name", "parent"];
+    readonly properties: {
+        readonly name: {
+            readonly description: "Name of the location.";
+            readonly type: "string";
+            readonly example: "New York";
+        };
+        readonly parent: {
+            readonly description: "Parent location ID or country 2-char iso code.";
+            readonly type: "string";
+            readonly example: "5";
+        };
+        readonly latitude: {
+            readonly description: "Latitude of the location - position can be used to find the nearest location in scheduler.";
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 40.73061;
+        };
+        readonly longitude: {
+            readonly description: "Longitude of the location - position can be used to find the nearest location in scheduler.";
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: -73.935242;
+        };
+        readonly weight: {
+            readonly description: "Weight is used to prefer or disfavor this group.";
+            readonly type: "integer";
+            readonly example: 1;
+        };
+    };
+    readonly type: "object";
+};
+export declare const RegionSchema: {
+    readonly description: "Class Region";
+    readonly properties: {
+        readonly id: {
+            readonly description: "ID of the region.";
+            readonly type: "integer";
+            readonly example: 1;
+        };
+        readonly name: {
+            readonly description: "Name of the region.";
+            readonly type: "string";
+            readonly example: "us-east";
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const AllowDenyTraitSchema: {
+    readonly description: "Add support for certificates to converters";
+    readonly properties: {
+        readonly browserRestriction: {
+            readonly type: "string";
+            readonly default: "everywhere";
+            readonly enum: readonly ["own", "everywhere", "custom"];
+        };
+        readonly browserAllow: {
+            readonly description: "Comma-separated whitelisted domains. This will be an array in the future";
+            readonly type: "string";
+        };
+        readonly browserDeny: {
+            readonly description: "Comma-separated blacklisted domains. This will be an array in the future";
+            readonly type: "string";
+        };
+    };
+    readonly type: "object";
+};
+export declare const UseCertificatesTraitSchema: {
+    readonly properties: {
+        readonly useClientCert: {
+            readonly type: "boolean";
+            readonly default: false;
+        };
+        readonly useCaCert: {
+            readonly type: "boolean";
+            readonly default: false;
+        };
+        readonly certificates: {
+            readonly oneOf: readonly [{
+                readonly $ref: "#/components/schemas/MonitorCertificates";
+            }, {
+                readonly type: "object";
+                readonly nullable: true;
+            }];
+        };
+    };
+    readonly type: "object";
+};
+export declare const EncryptionTraitSchema: {
+    readonly description: "Encryption-settable monitor";
+    readonly properties: {
+        readonly cipherList: {
+            readonly type: "string";
+            readonly default: "";
+            readonly enum: readonly ["ALL", "HIGH", "MEDIUM", ""];
+        };
+        readonly encryption: {
+            readonly description: "TODO: \"\" = negotiate? why nullable then? see in initializeEncryption";
+            readonly type: "string";
+            readonly default: "";
+            readonly enum: readonly ["tls", "tlsv1.0", "tlsv1.1", "tlsv1.2", "sslv3", ""];
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const HostPortTraitSchema: {
+    readonly description: "Add host:port support to the monitor schema - this may seem odd, but there are URL monitors, \n  host:port monitors and script monitors\n\nUse in CmLibMonitorSchemaAbstractMonitor and its descendants";
+    readonly properties: {
+        readonly host: {
+            readonly type: "string";
+            readonly example: "example.com";
+        };
+        readonly port: {
+            readonly type: "integer";
+            readonly format: "int32";
+        };
+    };
+    readonly type: "object";
+};
+export declare const IpVersionTraitSchema: {
+    readonly description: "Add IP version selection support to the monitor schema\n\nUse in CmLibMonitorSchemaAbstractMonitor and its descendants";
+    readonly properties: {
+        readonly ipVersion: {
+            readonly type: "integer";
+            readonly default: 0;
+            readonly enum: readonly [0, 4, 6];
+        };
+    };
+    readonly type: "object";
+};
+export declare const LoginTraitSchema: {
+    readonly description: "Add login support to the monitor schema\n\nUse in CmLibMonitorSchemaAbstractMonitor and its descendants";
+    readonly properties: {
+        readonly username: {
+            readonly type: "string";
+            readonly example: "myUsername";
+        };
+        readonly password: {
+            readonly type: "string";
+            readonly example: "myPassword";
+        };
+    };
+    readonly type: "object";
+};
+export declare const MatchStringTraitSchema: {
+    readonly description: "Add match string/regex support to the monitor schema\n\nUse in CmLibMonitorSchemaAbstractMonitor and its descendants";
+    readonly properties: {
+        readonly matchString: {
+            readonly type: "string";
+        };
+    };
+    readonly type: "object";
+};
+export declare const PostDataTraitSchema: {
+    readonly description: "Add post data support to the monitor schema\n\nUse in CmLibMonitorSchemaAbstractMonitor and its descendants";
+    readonly properties: {
+        readonly binary: {
+            readonly description: "Enable this option if POST, PUT or PATCH data is in a binary form. This value is disregarded on OPMS before 10.7.";
+            readonly type: "boolean";
+            readonly default: false;
+        };
+        readonly data: {
+            readonly description: "Data sent with the PUT, POST and PATCH requests. Binary data must be base64 encoded.";
+            readonly type: "string";
+            readonly format: "byte";
+        };
+    };
+    readonly type: "object";
+};
+export declare const ProxyTraitSchema: {
+    readonly description: "Add proxy support to the monitor schema";
+    readonly properties: {
+        readonly useProxy: {
+            readonly type: "boolean";
+            readonly default: false;
+        };
+        readonly proxyProtocol: {
+            readonly description: string;
+            readonly type: "string";
+            readonly enum: readonly ["http", "https", "socks5"];
+            readonly nullable: true;
+        };
+        readonly proxyAddress: {
+            readonly type: "string";
+            readonly nullable: true;
+        };
+        readonly proxyPort: {
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly proxyUsername: {
+            readonly type: "string";
+            readonly nullable: true;
+        };
+        readonly proxyPassword: {
+            readonly type: "string";
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const RequestHeadersTraitSchema: {
+    readonly properties: {
+        readonly requestHeaders: {
+            readonly type: "string";
+        };
+    };
+    readonly type: "object";
+};
+export declare const TransactionPatternsTraitSchema: {
+    readonly properties: {
+        readonly transactionPatterns: {
+            readonly type: "string";
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const UrlTraitSchema: {
+    readonly description: "Add host:port support to the monitor schema - this may seem odd, but there are URL monitors,\n   host:port monitors and script monitors\n\nUse in CmLibMonitorSchemaAbstractMonitor and its descendants";
+    readonly properties: {
+        readonly url: {
+            readonly type: "string";
+        };
+    };
+    readonly type: "object";
+};
+export declare const UserAgentTraitSchema: {
+    readonly description: "User-Agent-settable monitor";
+    readonly properties: {
+        readonly userAgent: {
+            readonly description: "Free format user agent to be used with requests, default empty string = native for the agent";
+            readonly type: "string";
+            readonly default: "";
+        };
+    };
+    readonly type: "object";
+};
+export declare const VerifyCertificateTraitSchema: {
+    readonly description: "monitor allowing verify certificate setting";
+    readonly properties: {
+        readonly verifyCertificate: {
+            readonly type: "boolean";
+            readonly default: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const MonitorSchema: {
+    readonly description: "Common fields present for all monitors";
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly id: {
+                readonly type: "integer";
+                readonly format: "int64";
+                readonly example: 1;
+            };
+            readonly status: {
+                readonly description: "Status of the monitor (read only). The status of the folder is not reflected.";
+                readonly type: "string";
+                readonly enum: readonly ["deleted", "inactive", "active", "unconfirmed", "locked", "error"];
+                readonly nullable: true;
+            };
+            readonly unhealthy: {
+                readonly description: string;
+                readonly type: "boolean";
+                readonly nullable: true;
+            };
+            readonly inMaintenance: {
+                readonly description: "Is monitor currently in maintenance mode? (read only)";
+                readonly type: "boolean";
+                readonly nullable: true;
+            };
+        };
+    }];
+};
+export declare const MonitorCreateSchema: {
+    readonly description: "Common fields for creating any monitor";
+    readonly required: readonly ["name", "type", "check", "alert", "checkpoint"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly type: {
+                readonly description: "The monitor type.";
+                readonly type: "string";
+                readonly enum: readonly ["http", "https", "connect", "dns", "dnsa", "dnsns", "domain", "ftp", "ftps", "imap", "ldap", "ping", "plugin", "pop3", "scp", "sftp", "sip", "smtp", "telnet", "browser", "script", "tls", "websocket"];
+            };
+        };
+    }];
+};
+export declare const MonitorUpdateSchema: {
+    readonly description: "Common updatable fields for all monitors";
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly example: "My Monitor Name";
+        };
+        readonly folderId: {
+            readonly description: "The folder id where the monitor will be put. 0 means no folder.";
+            readonly type: "integer";
+            readonly example: 1;
+        };
+        readonly maintenanceGroupIds: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "integer";
+            };
+            readonly example: readonly [1, 2, 3];
+        };
+        readonly tagNames: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly example: readonly ["tag1", "tag2"];
+        };
+        readonly transactionTag: {
+            readonly type: "string";
+            readonly example: "{agent_name}";
+        };
+        readonly userNote: {
+            readonly type: "string";
+            readonly example: "Note - any user-specified value will be stored";
+        };
+        readonly timezone: {
+            readonly description: string;
+            readonly type: "string";
+            readonly example: "America/Los_Angeles";
+            readonly nullable: true;
+        };
+        readonly check: {
+            readonly $ref: "#/components/schemas/MonitorCheck";
+        };
+        readonly alert: {
+            readonly $ref: "#/components/schemas/MonitorAlert";
+        };
+        readonly checkpoint: {
+            readonly $ref: "#/components/schemas/MonitorCheckpoint";
+        };
+        readonly noScheduleOnMaintenance: {
+            readonly description: string;
+            readonly type: "boolean";
+            readonly default: false;
+            readonly nullable: true;
+        };
+        readonly noRescheduleOnFailure: {
+            readonly description: string;
+            readonly type: "boolean";
+            readonly default: false;
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const MonitorAlertSchema: {
+    readonly description: "Class Alert";
+    readonly properties: {
+        readonly timeWarn: {
+            readonly type: "integer";
+            readonly example: 2500;
+        };
+        readonly timePoor: {
+            readonly type: "integer";
+            readonly example: 6000;
+        };
+        readonly timeOut: {
+            readonly type: "integer";
+            readonly example: 10;
+        };
+        readonly alertAfter: {
+            readonly type: "integer";
+            readonly enum: readonly [-1, 0, 1, 2, 3, 4];
+            readonly example: 1;
+        };
+        readonly dontDoPostMortem: {
+            readonly description: "Currently has no effect";
+            readonly type: "boolean";
+            readonly example: false;
+        };
+        readonly contactId: {
+            readonly type: "integer";
+            readonly example: 1;
+            readonly nullable: true;
+        };
+        readonly notifyWhenUp: {
+            readonly type: "boolean";
+            readonly example: true;
+        };
+        readonly quietPeriod: {
+            readonly type: "string";
+            readonly enum: readonly ["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"];
+            readonly nullable: true;
+        };
+        readonly checkThreshold: {
+            readonly type: "integer";
+            readonly enum: readonly [1, 2, 3, 4, 5];
+            readonly example: 1;
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const MonitorCertificatesSchema: {
+    readonly description: "Class Certificate";
+    readonly properties: {
+        readonly ca: {
+            readonly description: "CA certificate or chain for peer verification, either in PKCS12 or PEM format";
+            readonly type: "string";
+        };
+        readonly client: {
+            readonly description: string;
+            readonly type: "string";
+        };
+        readonly clientPassword: {
+            readonly type: "string";
+        };
+    };
+    readonly type: "object";
+};
+export declare const MonitorCheckSchema: {
+    readonly description: "Class Check";
+    readonly properties: {
+        readonly mode: {
+            readonly description: "Scheduler modes - 0(sequential), 1(multi), 4(sequential asynchronous), 5(multi asynchronous). If unsure, use 0";
+            readonly type: "integer";
+            readonly enum: readonly [0, 1, 4, 5];
+            readonly example: 0;
+        };
+        readonly interval: {
+            readonly type: "string";
+            readonly example: "00:05:00";
+        };
+        readonly periodFrom: {
+            readonly type: "string";
+            readonly example: "00:00";
+        };
+        readonly periodTo: {
+            readonly type: "string";
+            readonly example: "23:59";
+        };
+        readonly days: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "integer";
+            };
+            readonly example: readonly [0, 1, 2, 3, 4, 5, 6];
+        };
+    };
+    readonly type: "object";
+};
+export declare const MonitorCheckpointSchema: {
+    readonly description: "Class Checkpoint";
+    readonly properties: {
+        readonly usePublic: {
+            readonly type: "boolean";
+            readonly example: true;
+        };
+        readonly groupIds: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "integer";
+            };
+            readonly example: readonly [1, 2, 3];
+            readonly nullable: true;
+        };
+        readonly algorithm: {
+            readonly type: "string";
+            readonly enum: readonly ["master", "random", "seq", "sticky"];
+            readonly example: "random";
+        };
+        readonly defaultGroupId: {
+            readonly type: "integer";
+            readonly example: 1;
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const FtpCommonTraitSchema: {
+    readonly description: "Common FTP/S monitors' fields";
+    readonly properties: {
+        readonly path: {
+            readonly type: "string";
+            readonly example: "/dir";
+        };
+        readonly connectionMode: {
+            readonly type: "integer";
+            readonly default: 2;
+            readonly enum: readonly [0, 1, 2];
+        };
+    };
+    readonly type: "object";
+};
+export declare const HttpCommonTraitSchema: {
+    readonly description: "Common HTTP/S monitors' fields";
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/UrlTrait";
+    }, {
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/RequestHeadersTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UserAgentTrait";
+    }, {
+        readonly $ref: "#/components/schemas/PostDataTrait";
+    }, {
+        readonly properties: {
+            readonly httpMethod: {
+                readonly description: string;
+                readonly type: "string";
+                readonly default: "GET";
+                readonly enum: readonly ["", "GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
+            };
+            readonly acceptedHttpCodes: {
+                readonly type: "string";
+            };
+            readonly avoidCompression: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly useNtlm: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly redirectLimit: {
+                readonly type: "integer";
+                readonly default: 5;
+                readonly maximum: 10;
+                readonly minimum: 0;
+            };
+        };
+    }];
+};
+export declare const BrowserSchema: {
+    readonly required: readonly ["url", "browserRestriction"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/RequestHeadersTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UserAgentTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/AllowDenyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/TransactionPatternsTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly url: {
+                readonly type: "string";
+                readonly example: "https://www.example.com";
+            };
+            readonly jsErrorReport: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly elemErrorReport: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly toggleQuiescence: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly postVariables: {
+                readonly type: "string";
+            };
+        };
+    }];
+};
+export declare const BrowserCreateSchema: {
+    readonly required: readonly ["url", "browserRestriction"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/RequestHeadersTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UserAgentTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/AllowDenyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/TransactionPatternsTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly url: {
+                readonly type: "string";
+                readonly example: "https://www.example.com";
+            };
+            readonly jsErrorReport: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly elemErrorReport: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly toggleQuiescence: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly postVariables: {
+                readonly type: "string";
+            };
+        };
+    }];
+};
+export declare const BrowserUpdateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/RequestHeadersTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UserAgentTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/AllowDenyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/TransactionPatternsTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly url: {
+                readonly type: "string";
+                readonly example: "https://www.example.com";
+            };
+            readonly jsErrorReport: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly elemErrorReport: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly toggleQuiescence: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly postVariables: {
+                readonly type: "string";
+            };
+        };
+    }];
+};
+export declare const ConnectSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }];
+};
+export declare const ConnectCreateSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }];
+};
+export declare const ConnectUpdateSchema: {
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }];
+};
+export declare const DnsSchema: {
+    readonly description: "Class Dns";
+    readonly required: readonly ["domainName", "port"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly domainName: {
+                readonly type: "string";
+                readonly example: "example.com";
+            };
+            readonly port: {
+                readonly type: "integer";
+                readonly format: "int32";
+                readonly default: 53;
+            };
+            readonly recordType: {
+                readonly type: "string";
+                readonly default: "A";
+                readonly enum: readonly ["A", "AAAA", "MX", "NS", "CNAME", "PTR", "SOA", "TXT"];
+            };
+            readonly expectedResult: {
+                readonly description: "Comma-separated expected RR values. This will be an array in the future";
+                readonly type: "string";
+                readonly example: "1.2.3.4,2.3.4.5";
+            };
+            readonly retries: {
+                readonly type: "integer";
+                readonly default: 2;
+                readonly enum: readonly [0, 1, 2, 3];
+            };
+            readonly match: {
+                readonly type: "integer";
+                readonly default: 0;
+                readonly enum: readonly [-1, 0, 1];
+            };
+            readonly protocol: {
+                readonly type: "string";
+                readonly default: "udp";
+                readonly enum: readonly ["tcp", "udp"];
+            };
+            readonly target: {
+                readonly type: "string";
+                readonly default: "local";
+            };
+            readonly respondThreshold: {
+                readonly type: "integer";
+                readonly default: 1;
+                readonly enum: readonly [1, 2, 3, 4, 5, 6, 7];
+            };
+            readonly delimiter: {
+                readonly type: "string";
+                readonly default: "";
+                readonly enum: readonly ["", ",", "|", ";", "#|#", "#;#", "#ASM_ITEM_DELIMITER#"];
+            };
+        };
+    }];
+};
+export declare const DnsCreateSchema: {
+    readonly description: "Class Dns";
+    readonly required: readonly ["domainName", "port"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly domainName: {
+                readonly type: "string";
+                readonly example: "example.com";
+            };
+            readonly port: {
+                readonly type: "integer";
+                readonly format: "int32";
+                readonly default: 53;
+            };
+            readonly recordType: {
+                readonly type: "string";
+                readonly default: "A";
+                readonly enum: readonly ["A", "AAAA", "MX", "NS", "CNAME", "PTR", "SOA", "TXT"];
+            };
+            readonly expectedResult: {
+                readonly description: "Comma-separated expected RR values. This will be an array in the future";
+                readonly type: "string";
+                readonly example: "1.2.3.4,2.3.4.5";
+            };
+            readonly retries: {
+                readonly type: "integer";
+                readonly default: 2;
+                readonly enum: readonly [0, 1, 2, 3];
+            };
+            readonly match: {
+                readonly type: "integer";
+                readonly default: 0;
+                readonly enum: readonly [-1, 0, 1];
+            };
+            readonly protocol: {
+                readonly type: "string";
+                readonly default: "udp";
+                readonly enum: readonly ["tcp", "udp"];
+            };
+            readonly target: {
+                readonly type: "string";
+                readonly default: "local";
+            };
+            readonly respondThreshold: {
+                readonly type: "integer";
+                readonly default: 1;
+                readonly enum: readonly [1, 2, 3, 4, 5, 6, 7];
+            };
+            readonly delimiter: {
+                readonly type: "string";
+                readonly default: "";
+                readonly enum: readonly ["", ",", "|", ";", "#|#", "#;#", "#ASM_ITEM_DELIMITER#"];
+            };
+        };
+    }];
+};
+export declare const DnsUpdateSchema: {
+    readonly description: "Class Monitor";
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly domainName: {
+                readonly type: "string";
+                readonly example: "example.com";
+            };
+            readonly port: {
+                readonly type: "integer";
+                readonly format: "int32";
+                readonly default: 53;
+            };
+            readonly recordType: {
+                readonly type: "string";
+                readonly default: "A";
+                readonly enum: readonly ["A", "AAAA", "MX", "NS", "CNAME", "PTR", "SOA", "TXT"];
+            };
+            readonly expectedResult: {
+                readonly description: "Comma-separated expected RR values. This will be an array in the future";
+                readonly type: "string";
+                readonly example: "1.2.3.4,2.3.4.5";
+            };
+            readonly retries: {
+                readonly type: "integer";
+                readonly default: 2;
+                readonly enum: readonly [0, 1, 2, 3];
+            };
+            readonly match: {
+                readonly type: "integer";
+                readonly default: 0;
+                readonly enum: readonly [-1, 0, 1];
+            };
+            readonly protocol: {
+                readonly type: "string";
+                readonly default: "udp";
+                readonly enum: readonly ["tcp", "udp"];
+            };
+            readonly target: {
+                readonly type: "string";
+                readonly default: "local";
+            };
+            readonly respondThreshold: {
+                readonly type: "integer";
+                readonly default: 1;
+                readonly enum: readonly [1, 2, 3, 4, 5, 6, 7];
+            };
+            readonly delimiter: {
+                readonly type: "string";
+                readonly default: "";
+                readonly enum: readonly ["", ",", "|", ";", "#|#", "#;#", "#ASM_ITEM_DELIMITER#"];
+            };
+        };
+    }];
+};
+export declare const DnsaSchema: {
+    readonly required: readonly ["port", "path", "maxQueries"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly example: "pop.dmo.com=63.151.147.25";
+            };
+            readonly maxQueries: {
+                readonly type: "integer";
+                readonly format: "int32";
+                readonly default: 3;
+            };
+        };
+    }];
+};
+export declare const DnsaCreateSchema: {
+    readonly required: readonly ["port", "path", "maxQueries"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly example: "pop.dmo.com=63.151.147.25";
+            };
+            readonly maxQueries: {
+                readonly type: "integer";
+                readonly format: "int32";
+                readonly default: 3;
+            };
+        };
+    }];
+};
+export declare const DnsaUpdateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly example: "pop.dmo.com=63.151.147.25";
+            };
+            readonly maxQueries: {
+                readonly type: "integer";
+                readonly format: "int32";
+                readonly default: 3;
+            };
+        };
+    }];
+};
+export declare const DnsnsSchema: {
+    readonly required: readonly ["port", "path", "maxQueries"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly example: "";
+            };
+            readonly maxQueries: {
+                readonly type: "integer";
+                readonly format: "int32";
+                readonly default: 3;
+            };
+        };
+    }];
+};
+export declare const DnsnsCreateSchema: {
+    readonly required: readonly ["port", "path", "maxQueries"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly example: "";
+            };
+            readonly maxQueries: {
+                readonly type: "integer";
+                readonly format: "int32";
+                readonly default: 3;
+            };
+        };
+    }];
+};
+export declare const DnsnsUpdateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly example: "";
+            };
+            readonly maxQueries: {
+                readonly type: "integer";
+                readonly format: "int32";
+                readonly default: 3;
+            };
+        };
+    }];
+};
+export declare const DomainSchema: {
+    readonly description: "Class Domain";
+    readonly required: readonly ["domainName", "port", "retries", "protocol", "target", "respondThreshold"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly domainName: {
+                readonly type: "string";
+                readonly example: "example.com";
+            };
+            readonly port: {
+                readonly type: "integer";
+                readonly format: "int32";
+                readonly default: 53;
+            };
+            readonly retries: {
+                readonly type: "integer";
+                readonly default: 2;
+                readonly enum: readonly [0, 1, 2, 3];
+            };
+            readonly protocol: {
+                readonly type: "string";
+                readonly default: "udp";
+                readonly enum: readonly ["tcp", "udp"];
+            };
+            readonly target: {
+                readonly type: "string";
+                readonly default: "listed";
+            };
+            readonly respondThreshold: {
+                readonly type: "integer";
+                readonly default: 1;
+                readonly enum: readonly [1, 2, 3, 4, 5, 6, 7];
+            };
+            readonly doZoneTransfer: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+        };
+    }];
+};
+export declare const DomainCreateSchema: {
+    readonly description: "Class Domain";
+    readonly required: readonly ["domainName", "port", "retries", "protocol", "target", "respondThreshold"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly domainName: {
+                readonly type: "string";
+                readonly example: "example.com";
+            };
+            readonly port: {
+                readonly type: "integer";
+                readonly format: "int32";
+                readonly default: 53;
+            };
+            readonly retries: {
+                readonly type: "integer";
+                readonly default: 2;
+                readonly enum: readonly [0, 1, 2, 3];
+            };
+            readonly protocol: {
+                readonly type: "string";
+                readonly default: "udp";
+                readonly enum: readonly ["tcp", "udp"];
+            };
+            readonly target: {
+                readonly type: "string";
+                readonly default: "listed";
+            };
+            readonly respondThreshold: {
+                readonly type: "integer";
+                readonly default: 1;
+                readonly enum: readonly [1, 2, 3, 4, 5, 6, 7];
+            };
+            readonly doZoneTransfer: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+        };
+    }];
+};
+export declare const DomainUpdateSchema: {
+    readonly description: "Class Monitor";
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly domainName: {
+                readonly type: "string";
+                readonly example: "example.com";
+            };
+            readonly port: {
+                readonly type: "integer";
+                readonly format: "int32";
+                readonly default: 53;
+            };
+            readonly retries: {
+                readonly type: "integer";
+                readonly default: 2;
+                readonly enum: readonly [0, 1, 2, 3];
+            };
+            readonly protocol: {
+                readonly type: "string";
+                readonly default: "udp";
+                readonly enum: readonly ["tcp", "udp"];
+            };
+            readonly target: {
+                readonly type: "string";
+                readonly default: "listed";
+            };
+            readonly respondThreshold: {
+                readonly type: "integer";
+                readonly default: 1;
+                readonly enum: readonly [1, 2, 3, 4, 5, 6, 7];
+            };
+            readonly doZoneTransfer: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+        };
+    }];
+};
+export declare const FtpSchema: {
+    readonly description: "FTP monitor";
+    readonly required: readonly ["host", "port", "connectionMode"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/FtpCommonTrait";
+    }, {
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }];
+};
+export declare const FtpCreateSchema: {
+    readonly required: readonly ["host", "port", "connectionMode"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/FtpCommonTrait";
+    }, {
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }];
+};
+export declare const FtpUpdateSchema: {
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/FtpCommonTrait";
+    }, {
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }];
+};
+export declare const FtpsSchema: {
+    readonly required: readonly ["host", "port", "connectionMode"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/FtpCommonTrait";
+    }, {
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }];
+};
+export declare const FtpsCreateSchema: {
+    readonly required: readonly ["host", "port", "connectionMode"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/FtpCommonTrait";
+    }, {
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }];
+};
+export declare const FtpsUpdateSchema: {
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/FtpCommonTrait";
+    }, {
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }];
+};
+export declare const HttpSchema: {
+    readonly description: "The definition of HTTP monitor type";
+    readonly required: readonly ["url"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HttpCommonTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }];
+};
+export declare const HttpCreateSchema: {
+    readonly required: readonly ["url"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HttpCommonTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }];
+};
+export declare const HttpUpdateSchema: {
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HttpCommonTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }];
+};
+export declare const HttpsSchema: {
+    readonly required: readonly ["url"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HttpCommonTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UseCertificatesTrait";
+    }, {
+        readonly $ref: "#/components/schemas/EncryptionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Http";
+    }];
+};
+export declare const HttpsCreateSchema: {
+    readonly required: readonly ["url"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HttpCommonTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UseCertificatesTrait";
+    }, {
+        readonly $ref: "#/components/schemas/EncryptionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }];
+};
+export declare const HttpsUpdateSchema: {
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HttpCommonTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UseCertificatesTrait";
+    }, {
+        readonly $ref: "#/components/schemas/EncryptionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }];
+};
+export declare const ImapSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly example: "/";
+            };
+            readonly sslEncryption: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly emailAddress: {
+                readonly type: "string";
+                readonly example: "myUsername@example.com";
+            };
+        };
+    }];
+};
+export declare const ImapCreateSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly example: "/";
+            };
+            readonly sslEncryption: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly emailAddress: {
+                readonly type: "string";
+                readonly example: "myUsername@example.com";
+            };
+        };
+    }];
+};
+export declare const ImapUpdateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly example: "/";
+            };
+            readonly sslEncryption: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly emailAddress: {
+                readonly type: "string";
+                readonly example: "myUsername@example.com";
+            };
+        };
+    }];
+};
+export declare const LdapSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly description: "The search base and filter. Spaces in the filter must be replaced with %20";
+                readonly type: "string";
+                readonly example: "searchbase??sub?filter";
+            };
+            readonly sslEncryption: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+        };
+    }];
+};
+export declare const LdapCreateSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly description: "The search base and filter. Spaces in the filter must be replaced with %20";
+                readonly type: "string";
+                readonly example: "searchbase??sub?filter";
+            };
+            readonly sslEncryption: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+        };
+    }];
+};
+export declare const LdapUpdateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly description: "The search base and filter. Spaces in the filter must be replaced with %20";
+                readonly type: "string";
+                readonly example: "searchbase??sub?filter";
+            };
+            readonly sslEncryption: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+        };
+    }];
+};
+export declare const PingSchema: {
+    readonly required: readonly ["host", "packetLossThreshold"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly host: {
+                readonly type: "string";
+                readonly example: "example.com";
+            };
+            readonly packetLossThreshold: {
+                readonly description: "Packet loss in % (1-100)";
+                readonly type: "integer";
+                readonly default: 100;
+                readonly maximum: 100;
+                readonly minimum: 1;
+            };
+        };
+    }];
+};
+export declare const PingCreateSchema: {
+    readonly required: readonly ["host", "packetLossThreshold"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly host: {
+                readonly type: "string";
+                readonly example: "example.com";
+            };
+            readonly packetLossThreshold: {
+                readonly description: "Packet loss in % (1-100)";
+                readonly type: "integer";
+                readonly default: 100;
+                readonly maximum: 100;
+                readonly minimum: 1;
+            };
+        };
+    }];
+};
+export declare const PingUpdateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly host: {
+                readonly type: "string";
+                readonly example: "example.com";
+            };
+            readonly packetLossThreshold: {
+                readonly description: "Packet loss in % (1-100)";
+                readonly type: "integer";
+                readonly default: 100;
+                readonly maximum: 100;
+                readonly minimum: 1;
+            };
+        };
+    }];
+};
+export declare const PluginSchema: {
+    readonly required: readonly ["url"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/UrlTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly parameters: {
+                readonly type: "string";
+            };
+        };
+    }];
+};
+export declare const PluginCreateSchema: {
+    readonly required: readonly ["url"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/UrlTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly parameters: {
+                readonly type: "string";
+            };
+        };
+    }];
+};
+export declare const PluginUpdateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/UrlTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly parameters: {
+                readonly type: "string";
+            };
+        };
+    }];
+};
+export declare const Pop3Schema: {
+    readonly required: readonly ["host", "port"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly sslEncryption: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly emailAddress: {
+                readonly type: "string";
+                readonly example: "me@example.com";
+            };
+        };
+    }];
+};
+export declare const Pop3CreateSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly sslEncryption: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly emailAddress: {
+                readonly type: "string";
+                readonly example: "me@example.com";
+            };
+        };
+    }];
+};
+export declare const Pop3UpdateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly sslEncryption: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly emailAddress: {
+                readonly type: "string";
+                readonly example: "me@example.com";
+            };
+        };
+    }];
+};
+export declare const ScpSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly example: "/";
+            };
+        };
+    }];
+};
+export declare const ScpCreateSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly example: "/";
+            };
+        };
+    }];
+};
+export declare const ScpUpdateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly example: "/";
+            };
+        };
+    }];
+};
+export declare const ScriptSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/UseCertificatesTrait";
+    }, {
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly host: {
+                readonly type: "string";
+                readonly default: "";
+            };
+            readonly port: {
+                readonly type: "integer";
+                readonly format: "int32";
+                readonly default: 80;
+            };
+            readonly path: {
+                readonly type: "string";
+            };
+            readonly encryption: {
+                readonly type: "string";
+                readonly enum: readonly ["tls", "tlsv1.0", "tlsv1.1", "tlsv1.2", "sslv3"];
+            };
+            readonly assertOnly: {
+                readonly type: "boolean";
+            };
+            readonly responseContent: {
+                readonly type: "boolean";
+            };
+            readonly scriptFile: {
+                readonly $ref: "#/components/schemas/MonitorScript";
+            };
+        };
+    }];
+};
+export declare const ScriptCreateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/UseCertificatesTrait";
+    }, {
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly host: {
+                readonly type: "string";
+                readonly default: "";
+            };
+            readonly port: {
+                readonly type: "integer";
+                readonly format: "int32";
+                readonly default: 80;
+            };
+            readonly path: {
+                readonly type: "string";
+            };
+            readonly encryption: {
+                readonly type: "string";
+                readonly enum: readonly ["tls", "tlsv1.0", "tlsv1.1", "tlsv1.2", "sslv3"];
+            };
+            readonly assertOnly: {
+                readonly type: "boolean";
+            };
+            readonly responseContent: {
+                readonly type: "boolean";
+            };
+            readonly scriptFile: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/components/schemas/MonitorScriptCreate";
+                }, {
+                    readonly type: "object";
+                    readonly nullable: true;
+                }];
+            };
+        };
+    }];
+};
+export declare const ScriptUpdateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/UseCertificatesTrait";
+    }, {
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly host: {
+                readonly type: "string";
+                readonly default: "";
+            };
+            readonly port: {
+                readonly type: "integer";
+                readonly format: "int32";
+                readonly default: 80;
+            };
+            readonly path: {
+                readonly type: "string";
+            };
+            readonly encryption: {
+                readonly type: "string";
+                readonly enum: readonly ["tls", "tlsv1.0", "tlsv1.1", "tlsv1.2", "sslv3"];
+            };
+            readonly assertOnly: {
+                readonly type: "boolean";
+            };
+            readonly responseContent: {
+                readonly type: "boolean";
+            };
+            readonly scriptFile: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/components/schemas/MonitorScriptCreate";
+                }, {
+                    readonly type: "object";
+                    readonly nullable: true;
+                }];
+            };
+        };
+    }];
+};
+export declare const SftpSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly example: "/dir";
+            };
+        };
+    }];
+};
+export declare const SftpCreateSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly example: "/dir";
+            };
+        };
+    }];
+};
+export declare const SftpUpdateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly example: "/dir";
+            };
+        };
+    }];
+};
+export declare const SipSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }];
+};
+export declare const SipCreateSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }];
+};
+export declare const SipUpdateSchema: {
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }];
+};
+export declare const SmtpSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }];
+};
+export declare const SmtpCreateSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }];
+};
+export declare const SmtpUpdateSchema: {
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }];
+};
+export declare const TelnetSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }];
+};
+export declare const TelnetCreateSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }];
+};
+export declare const TelnetUpdateSchema: {
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }];
+};
+export declare const TlsSchema: {
+    readonly description: "TLS monitor for server certificate monitoring";
+    readonly required: readonly ["host", "port"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UseCertificatesTrait";
+    }, {
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/EncryptionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly expirationShift: {
+                readonly type: "integer";
+                readonly default: "21";
+            };
+        };
+    }];
+};
+export declare const TlsCreateSchema: {
+    readonly required: readonly ["host", "port"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UseCertificatesTrait";
+    }, {
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/EncryptionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly expirationShift: {
+                readonly type: "integer";
+                readonly default: "21";
+            };
+        };
+    }];
+};
+export declare const TlsUpdateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/HostPortTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UseCertificatesTrait";
+    }, {
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/EncryptionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly expirationShift: {
+                readonly type: "integer";
+                readonly default: "21";
+            };
+        };
+    }];
+};
+export declare const WebdriverSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UseCertificatesTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UserAgentTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/AllowDenyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/TransactionPatternsTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly host: {
+                readonly type: "string";
+                readonly example: "example.com";
+            };
+            readonly elemErrorReport: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly toggleQuiescence: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly browserAgent: {
+                readonly description: string;
+                readonly type: "boolean";
+                readonly default: false;
+                readonly nullable: true;
+            };
+            readonly proxyExcludeHosts: {
+                readonly type: "string";
+            };
+            readonly remapHosts: {
+                readonly description: "Comma-separated, colon-separated domain pairs. This will be an array in the future";
+                readonly type: "string";
+                readonly example: "example.com:example.org,example1.com:example1.org";
+            };
+            readonly blockHtml5Media: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly browser: {
+                readonly type: "string";
+            };
+            readonly authenticationType: {
+                readonly type: "string";
+            };
+            readonly scriptFile: {
+                readonly $ref: "#/components/schemas/MonitorScript";
+            };
+        };
+    }];
+};
+export declare const WebdriverCreateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UseCertificatesTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UserAgentTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/AllowDenyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/TransactionPatternsTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly host: {
+                readonly type: "string";
+                readonly example: "example.com";
+            };
+            readonly elemErrorReport: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly toggleQuiescence: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly browserAgent: {
+                readonly description: string;
+                readonly type: "boolean";
+                readonly default: false;
+                readonly nullable: true;
+            };
+            readonly proxyExcludeHosts: {
+                readonly type: "string";
+            };
+            readonly remapHosts: {
+                readonly description: "Comma-separated, colon-separated domain pairs. This will be an array in the future";
+                readonly type: "string";
+                readonly example: "example.com:example.org,example1.com:example1.org";
+            };
+            readonly blockHtml5Media: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly browser: {
+                readonly type: "string";
+            };
+            readonly authenticationType: {
+                readonly type: "string";
+            };
+            readonly scriptFile: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/components/schemas/MonitorScriptCreate";
+                }, {
+                    readonly type: "object";
+                    readonly nullable: true;
+                }];
+            };
+        };
+    }];
+};
+export declare const WebdriverUpdateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UseCertificatesTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UserAgentTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/AllowDenyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/TransactionPatternsTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly host: {
+                readonly type: "string";
+                readonly example: "example.com";
+            };
+            readonly elemErrorReport: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly toggleQuiescence: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly browserAgent: {
+                readonly description: string;
+                readonly type: "boolean";
+                readonly default: false;
+                readonly nullable: true;
+            };
+            readonly proxyExcludeHosts: {
+                readonly type: "string";
+            };
+            readonly remapHosts: {
+                readonly description: "Comma-separated, colon-separated domain pairs. This will be an array in the future";
+                readonly type: "string";
+                readonly example: "example.com:example.org,example1.com:example1.org";
+            };
+            readonly blockHtml5Media: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly browser: {
+                readonly type: "string";
+            };
+            readonly authenticationType: {
+                readonly type: "string";
+            };
+            readonly scriptFile: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/components/schemas/MonitorScriptCreate";
+                }, {
+                    readonly type: "object";
+                    readonly nullable: true;
+                }];
+            };
+        };
+    }];
+};
+export declare const WebsocketSchema: {
+    readonly required: readonly ["url"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/UrlTrait";
+    }, {
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UseCertificatesTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/PostDataTrait";
+    }, {
+        readonly $ref: "#/components/schemas/RequestHeadersTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UserAgentTrait";
+    }, {
+        readonly $ref: "#/components/schemas/Monitor";
+    }, {
+        readonly properties: {
+            readonly healthCheck: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly idleDelay: {
+                readonly type: "integer";
+                readonly default: 0;
+            };
+        };
+    }];
+};
+export declare const WebsocketCreateSchema: {
+    readonly required: readonly ["url"];
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/UrlTrait";
+    }, {
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UseCertificatesTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/PostDataTrait";
+    }, {
+        readonly $ref: "#/components/schemas/RequestHeadersTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UserAgentTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorCreate";
+    }, {
+        readonly properties: {
+            readonly healthCheck: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly idleDelay: {
+                readonly type: "integer";
+                readonly default: 0;
+            };
+        };
+    }];
+};
+export declare const WebsocketUpdateSchema: {
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/UrlTrait";
+    }, {
+        readonly $ref: "#/components/schemas/ProxyTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UseCertificatesTrait";
+    }, {
+        readonly $ref: "#/components/schemas/VerifyCertificateTrait";
+    }, {
+        readonly $ref: "#/components/schemas/LoginTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MatchStringTrait";
+    }, {
+        readonly $ref: "#/components/schemas/IpVersionTrait";
+    }, {
+        readonly $ref: "#/components/schemas/PostDataTrait";
+    }, {
+        readonly $ref: "#/components/schemas/RequestHeadersTrait";
+    }, {
+        readonly $ref: "#/components/schemas/UserAgentTrait";
+    }, {
+        readonly $ref: "#/components/schemas/MonitorUpdate";
+    }, {
+        readonly properties: {
+            readonly healthCheck: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly idleDelay: {
+                readonly type: "integer";
+                readonly default: 0;
+            };
+        };
+    }];
+};
+export declare const MonitorFrameSchema: {
+    readonly description: "Class MonitorFrame\nThis schema is used in the APIv3 to get list of monitors when the performance matters.\nTo retrieve full list of monitor properties lots of per-monitor queries must be executed which is time consuming (e.g. maintenance status).\nThis schema contains only parameters that needs no extra queries and/or lengthy calculations.\nThese parameters should be sufficient to get list of monitors for charts, selection dropboxes etc.";
+    readonly properties: {
+        readonly id: {
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly example: 1;
+        };
+        readonly type: {
+            readonly description: "The monitor type.";
+            readonly type: "string";
+            readonly enum: readonly ["http", "https", "connect", "dns", "dnsa", "dnsns", "domain", "ftp", "ftps", "imap", "ldap", "ping", "plugin", "pop3", "scp", "sftp", "sip", "smtp", "telnet", "browser", "script"];
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly example: "My Monitor Name";
+        };
+        readonly folderId: {
+            readonly type: "integer";
+            readonly example: 1;
+        };
+        readonly status: {
+            readonly description: "Status of the monitor (read only). The status of the folder is not reflected.";
+            readonly type: "string";
+            readonly enum: readonly ["deleted", "inactive", "active", "unconfirmed", "locked", "error"];
+            readonly nullable: true;
+        };
+        readonly unhealthy: {
+            readonly description: string;
+            readonly type: "boolean";
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const MonitorScriptSchema: {
+    readonly description: "Class ScriptFile";
+    readonly type: "object";
+    readonly allOf: readonly [{
+        readonly $ref: "#/components/schemas/MonitorScriptCreate";
+    }, {
+        readonly properties: {
+            readonly scriptId: {
+                readonly description: "ID of the script";
+                readonly type: "integer";
+                readonly format: "int64";
+                readonly example: 1;
+            };
+            readonly content: {
+                readonly type: "string";
+                readonly example: "The script file content. The full script is only returned when fetching one individual monitor.";
+                readonly nullable: true;
+            };
+        };
+    }];
+};
+export declare const MonitorScriptCreateSchema: {
+    readonly description: "Class ScriptFileCreate";
+    readonly properties: {
+        readonly scriptId: {
+            readonly description: string;
+            readonly type: "integer";
+            readonly format: "int64";
+            readonly example: 1;
+            readonly nullable: true;
+        };
+        readonly contentArchive: {
+            readonly type: "string";
+            readonly example: "The original script file content. Use this field when creating or updating a monitor";
+            readonly nullable: true;
+        };
+        readonly parameters: {
+            readonly type: "string";
+            readonly example: "";
+            readonly nullable: true;
+        };
+        readonly stages: {
+            readonly type: "string";
+            readonly example: "";
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const MonitorTagSchema: {
+    readonly properties: {
+        readonly id: {
+            readonly type: "integer";
+            readonly format: "int";
+            readonly example: 1;
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly example: "abc";
+        };
+    };
+    readonly type: "object";
+};
+export declare const EventAssetSchema: {
+    readonly properties: {
+        readonly url: {
+            readonly type: "string";
+            readonly example: "https://www.example.com";
+        };
+        readonly type: {
+            readonly type: "string";
+            readonly enum: readonly ["jtl", "har", "http", "image", "video", "log", "console_log"];
+        };
+    };
+    readonly type: "object";
+};
+export declare const LogEventSchema: {
+    readonly properties: {
+        readonly id: {
+            readonly type: "string";
+            readonly example: "1";
+        };
+        readonly monitor: {
+            readonly $ref: "#/components/schemas/StatisticResource";
+        };
+        readonly location: {
+            readonly $ref: "#/components/schemas/StatisticResource";
+        };
+        readonly folder: {
+            readonly $ref: "#/components/schemas/StatisticResource";
+        };
+        readonly start: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly duration: {
+            readonly type: "integer";
+        };
+        readonly interval: {
+            readonly type: "integer";
+        };
+        readonly monitor_type: {
+            readonly type: "string";
+            readonly example: "http";
+        };
+        readonly result: {
+            readonly $ref: "#/components/schemas/EventResult";
+        };
+        readonly metrics: {
+            readonly $ref: "#/components/schemas/LogEventMetrics";
+        };
+        readonly assets: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/EventAsset";
+            };
+            readonly nullable: true;
+        };
+        readonly probeMetrics: {
+            readonly oneOf: readonly [{
+                readonly $ref: "#/components/schemas/ProbeMetrics";
+            }, {
+                readonly type: "object";
+                readonly nullable: true;
+            }];
+        };
+    };
+    readonly type: "object";
+};
+export declare const LogEventMetricsSchema: {
+    readonly properties: {
+        readonly rtime: {
+            readonly description: "Resolve time (ms)";
+            readonly type: "integer";
+            readonly example: 103;
+        };
+        readonly ctime: {
+            readonly description: "Connect time (ms)";
+            readonly type: "integer";
+            readonly example: 5;
+        };
+        readonly ptime: {
+            readonly description: "First byte time (ms)";
+            readonly type: "integer";
+            readonly example: 406;
+        };
+        readonly dtime: {
+            readonly description: "Download time (ms)";
+            readonly type: "integer";
+            readonly example: 330;
+        };
+        readonly utime: {
+            readonly description: "User interaction time (ms)";
+            readonly type: "integer";
+            readonly example: 739;
+        };
+        readonly dsize: {
+            readonly description: "Download size (bytes)";
+            readonly type: "integer";
+            readonly example: 1439;
+        };
+        readonly multi_probes_all: {
+            readonly description: "Number of multi-check probes performed, including internal errors";
+            readonly type: "integer";
+            readonly example: 5;
+        };
+        readonly multi_probes: {
+            readonly description: "Number of multi-check probes performed, excluding internal errors";
+            readonly type: "integer";
+            readonly example: 1;
+        };
+        readonly multi_probes_failed: {
+            readonly description: "Number of multi-check probes failed, excluding internal errors";
+            readonly type: "integer";
+            readonly example: 2;
+        };
+    };
+    readonly type: "object";
+};
+export declare const MetricResourceSchema: {
+    readonly properties: {
+        readonly probes: {
+            readonly type: "integer";
+            readonly example: 10;
+        };
+        readonly probe_ok: {
+            readonly type: "integer";
+            readonly example: 10;
+        };
+        readonly probe_errors: {
+            readonly type: "integer";
+            readonly example: 0;
+        };
+        readonly checks: {
+            readonly type: "integer";
+            readonly example: 10;
+        };
+        readonly check_errors: {
+            readonly type: "integer";
+            readonly example: 0;
+        };
+        readonly checks_maint: {
+            readonly type: "integer";
+            readonly example: 0;
+        };
+        readonly maint_errors: {
+            readonly type: "integer";
+            readonly example: 0;
+        };
+        readonly rtime: {
+            readonly type: "integer";
+            readonly example: 4;
+        };
+        readonly ctime: {
+            readonly type: "integer";
+            readonly example: 162;
+        };
+        readonly ptime: {
+            readonly type: "integer";
+            readonly example: 306;
+        };
+        readonly utime: {
+            readonly type: "integer";
+            readonly example: 2;
+        };
+        readonly dtime: {
+            readonly type: "integer";
+            readonly example: 307;
+        };
+        readonly rtime_ok: {
+            readonly type: "integer";
+            readonly example: 4;
+        };
+        readonly ctime_ok: {
+            readonly type: "integer";
+            readonly example: 162;
+        };
+        readonly ptime_ok: {
+            readonly type: "integer";
+            readonly example: 306;
+        };
+        readonly utime_ok: {
+            readonly type: "integer";
+            readonly example: 2;
+        };
+        readonly dtime_ok: {
+            readonly type: "integer";
+            readonly example: 307;
+        };
+        readonly dsize: {
+            readonly type: "integer";
+            readonly example: 546;
+        };
+        readonly dev_rtime: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 0;
+        };
+        readonly dev_ctime: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 173.14052096490872;
+        };
+        readonly dev_ptime: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 48.96978660357841;
+        };
+        readonly dev_utime: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 0;
+        };
+        readonly dev_dtime: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 45.98086558558903;
+        };
+        readonly dev_dsize: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 114;
+        };
+        readonly xtime: {
+            readonly type: "integer";
+            readonly example: 1;
+        };
+        readonly xtime_ok: {
+            readonly type: "integer";
+            readonly example: 1;
+        };
+        readonly xspeed: {
+            readonly type: "integer";
+            readonly example: 546000;
+        };
+        readonly upstatus: {
+            readonly type: "integer";
+            readonly example: 0;
+        };
+        readonly perfstatus: {
+            readonly type: "integer";
+            readonly example: 0;
+        };
+        readonly score: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 99;
+        };
+        readonly spi_score: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 469;
+        };
+        readonly spi_penalty: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 0;
+        };
+        readonly uptime: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 100;
+        };
+        readonly downtime: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 0;
+        };
+        readonly ttime: {
+            readonly type: "integer";
+            readonly example: 473;
+        };
+        readonly ttime_ok: {
+            readonly type: "integer";
+            readonly example: 473;
+        };
+        readonly dspeed: {
+            readonly type: "integer";
+            readonly example: 1776;
+        };
+        readonly slawarn: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 100;
+        };
+        readonly slapoor: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 100;
+        };
+        readonly apdex: {
+            readonly type: "number";
+            readonly format: "float";
+            readonly example: 1;
+        };
+    };
+    readonly type: "object";
+};
+export declare const ProbeMetricsSchema: {
+    readonly properties: {
+        readonly id: {
+            readonly type: "string";
+            readonly example: "8b8d61bc-8a03-11ee-b9d1-0242ac120002";
+        };
+        readonly startTime: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly duration: {
+            readonly type: "integer";
+        };
+        readonly failed: {
+            readonly type: "boolean";
+            readonly nullable: true;
+        };
+        readonly statusCode: {
+            readonly type: "integer";
+            readonly example: "0";
+            readonly nullable: true;
+        };
+        readonly statusString: {
+            readonly type: "string";
+            readonly example: "OK";
+            readonly nullable: true;
+        };
+        readonly domain: {
+            readonly type: "string";
+            readonly example: "example.com";
+            readonly nullable: true;
+        };
+        readonly performance: {
+            readonly type: "string";
+            readonly enum: readonly ["good", "poor", "bad"];
+            readonly nullable: true;
+        };
+        readonly metrics: {
+            readonly $ref: "#/components/schemas/StageMetrics";
+        };
+        readonly stages: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/Stage";
+            };
+        };
+    };
+    readonly type: "object";
+};
+export declare const EventResultSchema: {
+    readonly properties: {
+        readonly code: {
+            readonly type: "integer";
+            readonly example: 5;
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly example: "Result description";
+        };
+        readonly type: {
+            readonly type: "string";
+            readonly enum: readonly ["ok", "unconfirmed_error", "confirmed_error", "maintenance", "unscheduled"];
+        };
+        readonly performance: {
+            readonly description: "For successful checks this value is calculated based on total time and monitor thresholds";
+            readonly type: "string";
+            readonly enum: readonly ["good", "poor", "bad"];
+        };
+    };
+    readonly type: "object";
+};
+export declare const StageSchema: {
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly example: "Stage 1";
+        };
+        readonly startTime: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly duration: {
+            readonly type: "integer";
+        };
+        readonly failed: {
+            readonly type: "boolean";
+            readonly nullable: true;
+        };
+        readonly statusCode: {
+            readonly type: "integer";
+            readonly example: "0";
+            readonly nullable: true;
+        };
+        readonly statusString: {
+            readonly type: "string";
+            readonly example: "OK";
+            readonly nullable: true;
+        };
+        readonly CorID: {
+            readonly type: "string";
+            readonly example: string;
+            readonly nullable: true;
+        };
+        readonly metrics: {
+            readonly $ref: "#/components/schemas/StageMetrics";
+        };
+        readonly transactions: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/Transaction";
+            };
+        };
+    };
+    readonly type: "object";
+};
+export declare const StageMetricsSchema: {
+    readonly properties: {
+        readonly blocked: {
+            readonly description: "Time spent in HTTP client's queue before starting the request (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly tls: {
+            readonly description: "Time spent on the TLS handshake (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly dns: {
+            readonly description: "Time spent on resolution of the IP address from the URI (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly connect: {
+            readonly description: "Time spent on establishing connection to the monitored service (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly upload: {
+            readonly description: "Time spent on sending request (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly firstByte: {
+            readonly description: "Time since upload was completed until the server starts sending response (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly download: {
+            readonly description: "Time spent on receiving response (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly uploadSize: {
+            readonly description: "Size of request, including headers (bytes)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly downloadSize: {
+            readonly description: "Size of response, including headers (bytes)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly uploadHeadersSize: {
+            readonly description: "Size of request headers (bytes)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly downloadHeadersSize: {
+            readonly description: "Size of response headers (bytes)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly onContentLoad: {
+            readonly description: "Time since start of the stage until the onContentLoad event (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly onLoad: {
+            readonly description: "Time since start of the stage until the onLoad event (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly requestCount: {
+            readonly description: "Number of transactions in this stage";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly failedCount: {
+            readonly description: "Number of failed transactions";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly totalTime: {
+            readonly description: "Time spent executing transactions (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly redirectCount: {
+            readonly description: "Number of HTTP redirects";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly redirectTime: {
+            readonly description: "Total time spent on HTTP redirects";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+export declare const StatisticItemSchema: {
+    readonly required: readonly ["timestamp", "locations", "monitors"];
+    readonly properties: {
+        readonly timestamp: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly monitors: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/StatisticResource";
+            };
+        };
+        readonly locations: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/StatisticResource";
+            };
+        };
+        readonly metrics: {
+            readonly $ref: "#/components/schemas/MetricResource";
+        };
+    };
+    readonly type: "object";
+};
+export declare const StatisticResourceSchema: {
+    readonly required: readonly ["id", "name"];
+    readonly properties: {
+        readonly id: {
+            readonly type: "integer";
+            readonly example: 1;
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly example: "Monitor Name";
+        };
+    };
+    readonly type: "object";
+};
+export declare const TransactionSchema: {
+    readonly properties: {
+        readonly uri: {
+            readonly description: "URI of the monitored service";
+            readonly type: "string";
+            readonly example: "https://localhost/";
+        };
+        readonly serverIp: {
+            readonly description: "IP address of the monitored service";
+            readonly type: "string";
+            readonly example: "127.0.0.1";
+        };
+        readonly startTime: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly duration: {
+            readonly type: "integer";
+        };
+        readonly failed: {
+            readonly type: "boolean";
+            readonly nullable: true;
+        };
+        readonly statusCode: {
+            readonly type: "integer";
+            readonly example: "0";
+            readonly nullable: true;
+        };
+        readonly statusString: {
+            readonly type: "string";
+            readonly example: "OK";
+            readonly nullable: true;
+        };
+        readonly metrics: {
+            readonly $ref: "#/components/schemas/TransactionMetrics";
+        };
+    };
+    readonly type: "object";
+};
+export declare const TransactionMetricsSchema: {
+    readonly properties: {
+        readonly blocked: {
+            readonly description: "Time spent in HTTP client's queue before starting the request (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly tls: {
+            readonly description: "Time spent on the TLS handshake (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly dns: {
+            readonly description: "Time spent on resolution of the IP address from the URI (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly connect: {
+            readonly description: "Time spent on establishing connection to the monitored service (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly upload: {
+            readonly description: "Time spent on sending request (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly firstByte: {
+            readonly description: "Time since upload was completed until the server starts sending response (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly download: {
+            readonly description: "Time spent on receiving response (ms)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly uploadSize: {
+            readonly description: "Size of request, including headers (bytes)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly downloadSize: {
+            readonly description: "Size of response, including headers (bytes)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly uploadHeadersSize: {
+            readonly description: "Size of request headers (bytes)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+        readonly downloadHeadersSize: {
+            readonly description: "Size of response headers (bytes)";
+            readonly type: "integer";
+            readonly nullable: true;
+        };
+    };
+    readonly type: "object";
+};
+//# sourceMappingURL=schemas.gen.d.ts.map