@distilled.cloud/stackit 0.0.0-stage → 1.0.0-rc.13

package/lib/services/observability.d.ts

@@ -0,0 +1,2750 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import { type StackitOpError, type StackitOpContext } from "../protocol.ts";
+export type { StackitOpError, StackitOpContext };
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class BadRequest extends /*@__PURE__*/ BadRequest_base {
+}
+declare const Forbidden_base: S.Class<Forbidden, S.TaggedStruct<"Forbidden", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        AuthError: true;
+    };
+});
+export declare class Forbidden extends /*@__PURE__*/ Forbidden_base {
+}
+declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {
+    readonly code: any;
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+export declare class NotFound extends /*@__PURE__*/ NotFound_base {
+}
+export interface CreateAlertConfigReceiverRequestEmailConfigsItem {
+    /** SMTP authentication information. `Additional Validators:` * must be a syntactically valid email address */
+    authIdentity?: string;
+    /** SMTP authentication information. */
+    authPassword?: string | Redacted.Redacted<string>;
+    /** SMTP authentication information. */
+    authUsername?: string;
+    /** The sender address. `Additional Validators:` * must be a syntactically valid email address */
+    from?: string;
+    /** Whether to notify about resolved alerts. */
+    sendResolved?: boolean;
+    /** The SMTP host through which emails are sent. `Additional Validators:` * should only include the characters: a-zA-Z0-9_./@&?:- */
+    smarthost?: string;
+    /** The email address to send notifications to. `Additional Validators:` * must be a syntactically valid email address */
+    to?: string;
+}
+export declare const CreateAlertConfigReceiverRequestEmailConfigsItem: S.Schema<CreateAlertConfigReceiverRequestEmailConfigsItem>;
+/** Email configurations */
+export type CreateAlertConfigReceiverRequestEmailConfigsList = Array<CreateAlertConfigReceiverRequestEmailConfigsItem>;
+export declare const CreateAlertConfigReceiverRequestEmailConfigsList: S.Schema<CreateAlertConfigReceiverRequestEmailConfigsList>;
+export interface CreateAlertConfigReceiverRequestOpsgenieConfigsItem {
+    /** The API key to use when talking to the OpsGenie API. `Additional Validators:` * should only include the characters: a-zA-Z0-9- */
+    apiKey?: string | Redacted.Redacted<string>;
+    /** The host to send OpsGenie API requests to. `Additional Validators:` * must be a syntactically valid url address */
+    apiUrl?: string;
+    /** Priority level of alert. Possible values are P1, P2, P3, P4, and P5. */
+    priority?: string;
+    /** Whether to notify about resolved alerts. */
+    sendResolved?: boolean;
+    /** Comma separated list of tags attached to the notifications. */
+    tags?: string;
+}
+export declare const CreateAlertConfigReceiverRequestOpsgenieConfigsItem: S.Schema<CreateAlertConfigReceiverRequestOpsgenieConfigsItem>;
+/** Configuration for ops genie. */
+export type CreateAlertConfigReceiverRequestOpsgenieConfigsList = Array<CreateAlertConfigReceiverRequestOpsgenieConfigsItem>;
+export declare const CreateAlertConfigReceiverRequestOpsgenieConfigsList: S.Schema<CreateAlertConfigReceiverRequestOpsgenieConfigsList>;
+export interface CreateAlertConfigReceiverRequestWebHookConfigsItem {
+    /** Google Chat webhooks require special handling. If you set this property to true, it is treated as such. `Additional Validators:` * When set to true, msTeams must be false. */
+    googleChat?: boolean;
+    /** Microsoft Teams webhooks require special handling. If you set this property to true, it is treated as such. `Additional Validators:` * When set to true, googleChat must be false. */
+    msTeams?: boolean;
+    /** Whether to notify about resolved alerts. */
+    sendResolved?: boolean;
+    /** The endpoint to send HTTP POST requests to. `Additional Validators:` * must be a syntactically valid url address */
+    url?: string;
+}
+export declare const CreateAlertConfigReceiverRequestWebHookConfigsItem: S.Schema<CreateAlertConfigReceiverRequestWebHookConfigsItem>;
+export type CreateAlertConfigReceiverRequestWebHookConfigsList = Array<CreateAlertConfigReceiverRequestWebHookConfigsItem>;
+export declare const CreateAlertConfigReceiverRequestWebHookConfigsList: S.Schema<CreateAlertConfigReceiverRequestWebHookConfigsList>;
+export interface CreateAlertConfigReceiverRequest {
+    projectId: string;
+    instanceId: string;
+    /** Email configurations */
+    emailConfigs?: CreateAlertConfigReceiverRequestEmailConfigsList;
+    /** `Additional Validators:` * must be unique * should only include the characters: a-zA-Z0-9- */
+    name: string;
+    /** Configuration for ops genie. */
+    opsgenieConfigs?: CreateAlertConfigReceiverRequestOpsgenieConfigsList;
+    webHookConfigs?: CreateAlertConfigReceiverRequestWebHookConfigsList;
+}
+export declare const CreateAlertConfigReceiverRequest: S.Schema<CreateAlertConfigReceiverRequest>;
+export interface EmailConfig {
+    authIdentity?: string;
+    authPassword?: string | Redacted.Redacted<string>;
+    authUsername?: string;
+    from?: string;
+    sendResolved?: boolean;
+    smarthost?: string;
+    to: string;
+}
+export declare const EmailConfig: S.Schema<EmailConfig>;
+export type ReceiversEmailConfigsList = Array<EmailConfig>;
+export declare const ReceiversEmailConfigsList: S.Schema<ReceiversEmailConfigsList>;
+export interface OpsgenieConfig {
+    apiKey?: string | Redacted.Redacted<string>;
+    apiUrl?: string;
+    priority?: string;
+    sendResolved?: boolean;
+    tags?: string;
+}
+export declare const OpsgenieConfig: S.Schema<OpsgenieConfig>;
+export type ReceiversOpsgenieConfigsList = Array<OpsgenieConfig>;
+export declare const ReceiversOpsgenieConfigsList: S.Schema<ReceiversOpsgenieConfigsList>;
+export interface WebHook {
+    googleChat?: boolean;
+    msTeams?: boolean;
+    sendResolved?: boolean;
+    url: string;
+}
+export declare const WebHook: S.Schema<WebHook>;
+export type ReceiversWebHookConfigsList = Array<WebHook>;
+export declare const ReceiversWebHookConfigsList: S.Schema<ReceiversWebHookConfigsList>;
+export interface Receivers {
+    emailConfigs?: ReceiversEmailConfigsList;
+    name: string;
+    opsgenieConfigs?: ReceiversOpsgenieConfigsList;
+    webHookConfigs?: ReceiversWebHookConfigsList;
+}
+export declare const Receivers: S.Schema<Receivers>;
+export type AlertConfigReceiversResponseDataList = Array<Receivers>;
+export declare const AlertConfigReceiversResponseDataList: S.Schema<AlertConfigReceiversResponseDataList>;
+export interface AlertConfigReceiversResponse {
+    data: AlertConfigReceiversResponseDataList;
+    message: string;
+}
+export declare const AlertConfigReceiversResponse: S.Schema<AlertConfigReceiversResponse>;
+/** The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. */
+export type CreateAlertConfigRouteRequestGroupByList = Array<string>;
+export declare const CreateAlertConfigRouteRequestGroupByList: S.Schema<CreateAlertConfigRouteRequestGroupByList>;
+/** A list of matchers that an alert has to fulfill to match the node. A matcher is a string with a syntax inspired by PromQL and OpenMetrics. The syntax of a matcher consists of three tokens: * A valid Prometheus label name. * One of =, !=, =~, or !~. = means equals, != means that the strings are not equal, =~ is used for equality of regex expressions and !~ is used for un-equality of regex expressions. They have the same meaning as known from PromQL selectors. * A UTF-8 string, which may be enclosed in double quotes. Before or after each token, there may be any amount of whitespace. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters */
+export type CreateAlertConfigRouteRequestMatchersList = Array<string>;
+export declare const CreateAlertConfigRouteRequestMatchersList: S.Schema<CreateAlertConfigRouteRequestMatchersList>;
+export type CreateAlertConfigRouteRequestRoutesItemGroupByList = Array<string>;
+export declare const CreateAlertConfigRouteRequestRoutesItemGroupByList: S.Schema<CreateAlertConfigRouteRequestRoutesItemGroupByList>;
+/** As in one level above */
+export type CreateAlertConfigRouteRequestRoutesItemMatchersList = Array<string>;
+export declare const CreateAlertConfigRouteRequestRoutesItemMatchersList: S.Schema<CreateAlertConfigRouteRequestRoutesItemMatchersList>;
+/** Another child routes */
+export type CreateAlertConfigRouteRequestRoutesItemRoutesList = Array<unknown>;
+export declare const CreateAlertConfigRouteRequestRoutesItemRoutesList: S.Schema<CreateAlertConfigRouteRequestRoutesItemRoutesList>;
+/** As in one level above */
+export interface CreateAlertConfigRouteRequestRoutesItem {
+    /** Whether an alert should continue matching subsequent sibling nodes. */
+    continue?: boolean;
+    groupBy?: CreateAlertConfigRouteRequestRoutesItemGroupByList;
+    /** As in one level above */
+    groupInterval?: string;
+    /** As in one level above */
+    groupWait?: string;
+    /** As in one level above */
+    match?: unknown;
+    /** As in one level above */
+    matchRe?: unknown;
+    /** As in one level above */
+    matchers?: CreateAlertConfigRouteRequestRoutesItemMatchersList;
+    /** As in one level above */
+    receiver?: string;
+    /** As in one level above */
+    repeatInterval?: string;
+    /** Another child routes */
+    routes?: CreateAlertConfigRouteRequestRoutesItemRoutesList;
+}
+export declare const CreateAlertConfigRouteRequestRoutesItem: S.Schema<CreateAlertConfigRouteRequestRoutesItem>;
+/** Zero or more child routes. */
+export type CreateAlertConfigRouteRequestRoutesList = Array<CreateAlertConfigRouteRequestRoutesItem>;
+export declare const CreateAlertConfigRouteRequestRoutesList: S.Schema<CreateAlertConfigRouteRequestRoutesList>;
+export interface CreateAlertConfigRouteRequest {
+    projectId: string;
+    instanceId: string;
+    /** The continue parameter cannot be set to true on the root route because there are no subsequent sibling nodes to match. It must always be false. */
+    continue?: boolean;
+    /** The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. */
+    groupBy?: CreateAlertConfigRouteRequestGroupByList;
+    /** How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) `Additional Validators:` * must be a valid time format */
+    groupInterval?: string;
+    /** How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) `Additional Validators:` * must be a valid time format */
+    groupWait?: string;
+    /** map of key:value. A set of equality matchers an alert has to fulfill to match the node. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters * key and values should only include the characters: a-zA-Z0-9_./@&?:- */
+    match?: unknown;
+    /** map of key:value. A set of regex-matchers an alert has to fulfill to match the node. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters */
+    matchRe?: unknown;
+    /** A list of matchers that an alert has to fulfill to match the node. A matcher is a string with a syntax inspired by PromQL and OpenMetrics. The syntax of a matcher consists of three tokens: * A valid Prometheus label name. * One of =, !=, =~, or !~. = means equals, != means that the strings are not equal, =~ is used for equality of regex expressions and !~ is used for un-equality of regex expressions. They have the same meaning as known from PromQL selectors. * A UTF-8 string, which may be enclosed in double quotes. Before or after each token, there may be any amount of whitespace. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters */
+    matchers?: CreateAlertConfigRouteRequestMatchersList;
+    /** Receiver that should be one item of receivers `Additional Validators:` * must be a in name of receivers */
+    receiver: string;
+    /** How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). `Additional Validators:` * must be a valid time format */
+    repeatInterval?: string;
+    /** Zero or more child routes. */
+    routes?: CreateAlertConfigRouteRequestRoutesList;
+}
+export declare const CreateAlertConfigRouteRequest: S.Schema<CreateAlertConfigRouteRequest>;
+export type RouteGroupByList = Array<string>;
+export declare const RouteGroupByList: S.Schema<RouteGroupByList>;
+export type RouteMatchMap = {
+    [key: string]: string | undefined;
+};
+export declare const RouteMatchMap: S.Schema<RouteMatchMap>;
+export type RouteMatchReMap = {
+    [key: string]: string | undefined;
+};
+export declare const RouteMatchReMap: S.Schema<RouteMatchReMap>;
+export type RouteMatchersList = Array<string>;
+export declare const RouteMatchersList: S.Schema<RouteMatchersList>;
+export type RouteSerializerGroupByList = Array<string>;
+export declare const RouteSerializerGroupByList: S.Schema<RouteSerializerGroupByList>;
+export type RouteSerializerMatchMap = {
+    [key: string]: string | undefined;
+};
+export declare const RouteSerializerMatchMap: S.Schema<RouteSerializerMatchMap>;
+export type RouteSerializerMatchReMap = {
+    [key: string]: string | undefined;
+};
+export declare const RouteSerializerMatchReMap: S.Schema<RouteSerializerMatchReMap>;
+export type RouteSerializerMatchersList = Array<string>;
+export declare const RouteSerializerMatchersList: S.Schema<RouteSerializerMatchersList>;
+export type RouteSerializerRoutesItemMap = {
+    [key: string]: string | undefined;
+};
+export declare const RouteSerializerRoutesItemMap: S.Schema<RouteSerializerRoutesItemMap>;
+export type RouteSerializerRoutesList = Array<RouteSerializerRoutesItemMap>;
+export declare const RouteSerializerRoutesList: S.Schema<RouteSerializerRoutesList>;
+export interface RouteSerializer {
+    continue?: boolean;
+    groupBy?: RouteSerializerGroupByList;
+    groupInterval?: string;
+    groupWait?: string;
+    match?: RouteSerializerMatchMap;
+    matchRe?: RouteSerializerMatchReMap;
+    matchers?: RouteSerializerMatchersList;
+    receiver: string;
+    repeatInterval?: string;
+    routes?: RouteSerializerRoutesList;
+}
+export declare const RouteSerializer: S.Schema<RouteSerializer>;
+export type RouteRoutesList = Array<RouteSerializer>;
+export declare const RouteRoutesList: S.Schema<RouteRoutesList>;
+export interface Route {
+    continue?: boolean;
+    groupBy?: RouteGroupByList;
+    groupInterval?: string;
+    groupWait?: string;
+    match?: RouteMatchMap;
+    matchRe?: RouteMatchReMap;
+    matchers?: RouteMatchersList;
+    receiver: string;
+    repeatInterval?: string;
+    routes?: RouteRoutesList;
+}
+export declare const Route: S.Schema<Route>;
+export interface AlertConfigRouteResponse {
+    data: Route;
+    message: string;
+}
+export declare const AlertConfigRouteResponse: S.Schema<AlertConfigRouteResponse>;
+/** Rule definition. Must be either an Alerting Rule (using 'alert') or a Recording Rule (using 'record'). `Additional Validators:` * total config (all alert groups/rules) should not be bigger than 500000 characters as string since this the limitation of prometheus. */
+export interface CreateAlertgroupsRequestRulesItem {
+    /** The name of the alert. When this attribute is used, an Alerting Rule will be created. `Additional Validators:` * is the identifier and so unique in the group * should only include the characters: a-zA-Z0-9- * required when 'record' is not used in this rule, otherwise not allowed */
+    alert?: string;
+    /** Map of key:value. Annotations to add to each alert. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters * is not allowed to use when 'record' is used in this rule */
+    annotations?: unknown;
+    /** The PromQL expression to evaluate to create alerts when using the 'alert' attribute in this rule, or to create a metric when using the 'record' attribute. */
+    expr: string;
+    /** Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. `Additional Validators:` * must be a valid time string * is not allowed to use when 'record' is used in this rule */
+    for?: string;
+    /** Map of key:value. Labels to add or overwrite for each alert or metric. `Additional Validators:` * should not contain more than 10 keys * each key and value should not be longer than 200 characters */
+    labels?: unknown;
+    /** The name of the metric. When this attribute is used, an Recording Rule will be created. `Additional Validators:` * is the identifier and so unique in the group * should only include the characters: a-zA-Z0-9:_ * required when 'alert' is not used in this rule, otherwise not allowed */
+    record?: string;
+}
+export declare const CreateAlertgroupsRequestRulesItem: S.Schema<CreateAlertgroupsRequestRulesItem>;
+/** rules for the alert group */
+export type CreateAlertgroupsRequestRulesList = Array<CreateAlertgroupsRequestRulesItem>;
+export declare const CreateAlertgroupsRequestRulesList: S.Schema<CreateAlertgroupsRequestRulesList>;
+export interface CreateAlertgroupsRequest {
+    projectId: string;
+    instanceId: string;
+    /** How often rules in the group are evaluated. `Additional Validators:` * must be a valid time string * should be >=60s */
+    interval?: string;
+    /** The name of the group. Must be unique. `Additional Validators:` * is the identifier and so unique * should only include the characters: a-zA-Z0-9- */
+    name: string;
+    /** rules for the alert group */
+    rules: CreateAlertgroupsRequestRulesList;
+}
+export declare const CreateAlertgroupsRequest: S.Schema<CreateAlertgroupsRequest>;
+export type AlertRuleRecordAnnotationsMap = {
+    [key: string]: string | undefined;
+};
+export declare const AlertRuleRecordAnnotationsMap: S.Schema<AlertRuleRecordAnnotationsMap>;
+export type AlertRuleRecordLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const AlertRuleRecordLabelsMap: S.Schema<AlertRuleRecordLabelsMap>;
+export interface AlertRuleRecord {
+    alert?: string;
+    annotations?: AlertRuleRecordAnnotationsMap;
+    expr: string;
+    for?: string;
+    labels?: AlertRuleRecordLabelsMap;
+    record?: string;
+}
+export declare const AlertRuleRecord: S.Schema<AlertRuleRecord>;
+export type AlertGroupRulesList = Array<AlertRuleRecord>;
+export declare const AlertGroupRulesList: S.Schema<AlertGroupRulesList>;
+export interface AlertGroup {
+    interval?: string;
+    name: string;
+    rules: AlertGroupRulesList;
+}
+export declare const AlertGroup: S.Schema<AlertGroup>;
+export type AlertGroupsResponseDataList = Array<AlertGroup>;
+export declare const AlertGroupsResponseDataList: S.Schema<AlertGroupsResponseDataList>;
+export interface AlertGroupsResponse {
+    data: AlertGroupsResponseDataList;
+    message: string;
+}
+export declare const AlertGroupsResponse: S.Schema<AlertGroupsResponse>;
+export interface CreateAlertRecordRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+    /** The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. */
+    expr: string;
+    /** map of key:value. Labels to add or overwrite for each alert. `Additional Validators:` * should not contain more than 10 keys * each key and value should not be longer than 200 characters */
+    labels?: unknown;
+    /** The name of the record. `Additional Validators:` * is the identifier and so unique in the group */
+    record: string;
+}
+export declare const CreateAlertRecordRequest: S.Schema<CreateAlertRecordRequest>;
+export type AlertRecordLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const AlertRecordLabelsMap: S.Schema<AlertRecordLabelsMap>;
+export interface AlertRecord {
+    expr: string;
+    labels?: AlertRecordLabelsMap;
+    record: string;
+}
+export declare const AlertRecord: S.Schema<AlertRecord>;
+export type AlertRecordsResponseDataList = Array<AlertRecord>;
+export declare const AlertRecordsResponseDataList: S.Schema<AlertRecordsResponseDataList>;
+export interface AlertRecordsResponse {
+    data: AlertRecordsResponseDataList;
+    message: string;
+}
+export declare const AlertRecordsResponse: S.Schema<AlertRecordsResponse>;
+export interface CreateAlertrulesRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+    /** The name of the alert. `Additional Validators:` * is the identifier and so unique in the group * should only include the characters: a-zA-Z0-9- */
+    alert: string;
+    /** map of key:value. Annotations to add to each alert. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters */
+    annotations?: unknown;
+    /** The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. */
+    expr: string;
+    /** Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. `Additional Validators:` * must be a valid time string */
+    for?: string;
+    /** map of key:value. Labels to add or overwrite for each alert. `Additional Validators:` * should not contain more than 10 keys * each key and value should not be longer than 200 characters */
+    labels?: unknown;
+}
+export declare const CreateAlertrulesRequest: S.Schema<CreateAlertrulesRequest>;
+export type AlertRuleAnnotationsMap = {
+    [key: string]: string | undefined;
+};
+export declare const AlertRuleAnnotationsMap: S.Schema<AlertRuleAnnotationsMap>;
+export type AlertRuleLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const AlertRuleLabelsMap: S.Schema<AlertRuleLabelsMap>;
+export interface AlertRule {
+    alert: string;
+    annotations?: AlertRuleAnnotationsMap;
+    expr: string;
+    for?: string;
+    labels?: AlertRuleLabelsMap;
+}
+export declare const AlertRule: S.Schema<AlertRule>;
+export type AlertRulesResponseDataList = Array<AlertRule>;
+export declare const AlertRulesResponseDataList: S.Schema<AlertRulesResponseDataList>;
+export interface AlertRulesResponse {
+    data: AlertRulesResponseDataList;
+    message: string;
+}
+export declare const AlertRulesResponse: S.Schema<AlertRulesResponse>;
+export type CreateBackupRequestBackupTargetItem = "alertConfig" | "alertRules" | "scrapeConfig" | "grafana";
+export declare const CreateBackupRequestBackupTargetItem: any;
+export type CreateBackupRequestBackupTargetList = Array<CreateBackupRequestBackupTargetItem | (string & {})>;
+export declare const CreateBackupRequestBackupTargetList: S.Schema<CreateBackupRequestBackupTargetList>;
+export interface CreateBackupRequest {
+    projectId: string;
+    instanceId: string;
+    /** List of backup targets */
+    backupTarget?: CreateBackupRequestBackupTargetList;
+}
+export declare const CreateBackupRequest: S.Schema<CreateBackupRequest>;
+export interface Message {
+    message: string;
+}
+export declare const Message: S.Schema<Message>;
+export type CreateBackupScheduleRequestBackupTargetItem = "alertConfig" | "alertRules" | "scrapeConfig" | "grafana";
+export declare const CreateBackupScheduleRequestBackupTargetItem: any;
+export type CreateBackupScheduleRequestBackupTargetList = Array<CreateBackupScheduleRequestBackupTargetItem | (string & {})>;
+export declare const CreateBackupScheduleRequestBackupTargetList: S.Schema<CreateBackupScheduleRequestBackupTargetList>;
+export interface CreateBackupScheduleRequest {
+    projectId: string;
+    instanceId: string;
+    /** List of backup targets */
+    backupTarget?: CreateBackupScheduleRequestBackupTargetList;
+    /** The schedule for how often to create a backup. `Additional Validators:` * must be a valid cronjob format * must run less than hourly */
+    schedule: string;
+}
+export declare const CreateBackupScheduleRequest: S.Schema<CreateBackupScheduleRequest>;
+export interface BackupSchedulePostResponse {
+    message: string;
+    schedule: string;
+}
+export declare const BackupSchedulePostResponse: S.Schema<BackupSchedulePostResponse>;
+export interface CreateCertCheckRequest {
+    projectId: string;
+    instanceId: string;
+    /** cert to check */
+    source: string;
+}
+export declare const CreateCertCheckRequest: S.Schema<CreateCertCheckRequest>;
+export interface CertCheckChildResponse {
+    id: string;
+    source: string;
+}
+export declare const CertCheckChildResponse: S.Schema<CertCheckChildResponse>;
+export type CertCheckResponseCertChecksList = Array<CertCheckChildResponse>;
+export declare const CertCheckResponseCertChecksList: S.Schema<CertCheckResponseCertChecksList>;
+export interface CertCheckResponse {
+    certCheck?: CertCheckChildResponse;
+    certChecks: CertCheckResponseCertChecksList;
+    message: string;
+}
+export declare const CertCheckResponse: S.Schema<CertCheckResponse>;
+export interface CreateCredentialsRequest {
+    projectId: string;
+    instanceId: string;
+    /** description */
+    description?: string;
+}
+export declare const CreateCredentialsRequest: S.Schema<CreateCredentialsRequest>;
+export interface Credentials {
+    description?: string;
+    password: string | Redacted.Redacted<string>;
+    username: string;
+}
+export declare const Credentials: S.Schema<Credentials>;
+export interface CreateCredentialsResponse {
+    credentials: Credentials;
+    message: string;
+}
+export declare const CreateCredentialsResponse: S.Schema<CreateCredentialsResponse>;
+export interface CreateElasticsearchCheckRequest {
+    projectId: string;
+    instanceId: string;
+    /** password */
+    password?: string | Redacted.Redacted<string>;
+    /** url to check */
+    server: string;
+    /** username */
+    username?: string;
+}
+export declare const CreateElasticsearchCheckRequest: S.Schema<CreateElasticsearchCheckRequest>;
+export interface ElasticsearchCheckChildResponse {
+    id: string;
+    password?: string | Redacted.Redacted<string>;
+    server: string;
+    username?: string;
+}
+export declare const ElasticsearchCheckChildResponse: S.Schema<ElasticsearchCheckChildResponse>;
+export type ElasticsearchCheckResponseElasticsearchChecksList = Array<ElasticsearchCheckChildResponse>;
+export declare const ElasticsearchCheckResponseElasticsearchChecksList: S.Schema<ElasticsearchCheckResponseElasticsearchChecksList>;
+export interface ElasticsearchCheckResponse {
+    elasticsearchCheck?: ElasticsearchCheckChildResponse;
+    elasticsearchChecks: ElasticsearchCheckResponseElasticsearchChecksList;
+    message: string;
+}
+export declare const ElasticsearchCheckResponse: S.Schema<ElasticsearchCheckResponse>;
+export interface CreateHttpCheckRequest {
+    projectId: string;
+    instanceId: string;
+    /** url to check */
+    url: string;
+}
+export declare const CreateHttpCheckRequest: S.Schema<CreateHttpCheckRequest>;
+export interface HttpCheckChildResponse {
+    id: string;
+    url: string;
+}
+export declare const HttpCheckChildResponse: S.Schema<HttpCheckChildResponse>;
+export type HttpCheckResponseHttpChecksList = Array<HttpCheckChildResponse>;
+export declare const HttpCheckResponseHttpChecksList: S.Schema<HttpCheckResponseHttpChecksList>;
+export interface HttpCheckResponse {
+    httpCheck?: HttpCheckChildResponse;
+    httpChecks: HttpCheckResponseHttpChecksList;
+    message: string;
+}
+export declare const HttpCheckResponse: S.Schema<HttpCheckResponse>;
+export interface CreateInstanceRequest {
+    projectId: string;
+    /** If true, a default Grafana server admin user is created. It's recommended to set this to false and use STACKIT SSO (`Owner` or `Observability Grafana Server Admin` role) instead. It is still possible to manually create a new Grafana admin user via the Grafana UI later. */
+    grafanaAdminEnabled?: boolean;
+    /** Name of the service */
+    name?: string;
+    /** Additional parameters */
+    parameter?: unknown;
+    /** UUID of the plan to create/update */
+    planId: string;
+}
+export declare const CreateInstanceRequest: S.Schema<CreateInstanceRequest>;
+export interface CreateInstanceResponse {
+    dashboardUrl: string;
+    instanceId: string;
+    message: string;
+}
+export declare const CreateInstanceResponse: S.Schema<CreateInstanceResponse>;
+/** Rule definition. Must be either an Alerting Rule (using 'alert') or a Recording Rule (using 'record'). `Additional Validators:` * total config (all alert groups/rules) should not be bigger than 500000 characters as string since this the limitation of prometheus. */
+export interface CreateLogsAlertgroupsRequestRulesItem {
+    /** The name of the alert. When this attribute is used, an Alerting Rule will be created. `Additional Validators:` * is the identifier and so unique in the group * should only include the characters: a-zA-Z0-9- * required when 'record' is not used in this rule, otherwise not allowed */
+    alert?: string;
+    /** Map of key:value. Annotations to add to each alert. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters * is not allowed to use when 'record' is used in this rule */
+    annotations?: unknown;
+    /** The LogQL expression to evaluate to create alerts when using the 'alert' attribute in this rule, or to create a metric when using the 'record' attribute. */
+    expr: string;
+    /** Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. `Additional Validators:` * must be a valid time string * is not allowed to use when 'record' is used in this rule */
+    for?: string;
+    /** Map of key:value. Labels to add or overwrite for each alert or metric. `Additional Validators:` * should not contain more than 10 keys * each key and value should not be longer than 200 characters */
+    labels?: unknown;
+    /** The name of the metric. When this attribute is used, an Recording Rule will be created. `Additional Validators:` * is the identifier and so unique in the group * should only include the characters: a-zA-Z0-9:_ * required when 'alert' is not used in this rule, otherwise not allowed */
+    record?: string;
+}
+export declare const CreateLogsAlertgroupsRequestRulesItem: S.Schema<CreateLogsAlertgroupsRequestRulesItem>;
+/** rules for the alert group */
+export type CreateLogsAlertgroupsRequestRulesList = Array<CreateLogsAlertgroupsRequestRulesItem>;
+export declare const CreateLogsAlertgroupsRequestRulesList: S.Schema<CreateLogsAlertgroupsRequestRulesList>;
+export interface CreateLogsAlertgroupsRequest {
+    projectId: string;
+    instanceId: string;
+    /** How often rules in the group are evaluated. `Additional Validators:` * must be a valid time string * should be >=60s */
+    interval?: string;
+    /** The name of the group. Must be unique. `Additional Validators:` * is the identifier and so unique * should only include the characters: a-zA-Z0-9- */
+    name: string;
+    /** rules for the alert group */
+    rules: CreateLogsAlertgroupsRequestRulesList;
+}
+export declare const CreateLogsAlertgroupsRequest: S.Schema<CreateLogsAlertgroupsRequest>;
+export interface CreateMongodbCheckRequest {
+    projectId: string;
+    instanceId: string;
+    /** url to check */
+    server: string;
+}
+export declare const CreateMongodbCheckRequest: S.Schema<CreateMongodbCheckRequest>;
+export interface MongodbCheckChildResponse {
+    id: string;
+    server: string;
+}
+export declare const MongodbCheckChildResponse: S.Schema<MongodbCheckChildResponse>;
+export type MongodbCheckResponseMongodbChecksList = Array<MongodbCheckChildResponse>;
+export declare const MongodbCheckResponseMongodbChecksList: S.Schema<MongodbCheckResponseMongodbChecksList>;
+export interface MongodbCheckResponse {
+    message: string;
+    mongodbCheck?: MongodbCheckChildResponse;
+    mongodbChecks: MongodbCheckResponseMongodbChecksList;
+}
+export declare const MongodbCheckResponse: S.Schema<MongodbCheckResponse>;
+export interface CreateMysqlCheckRequest {
+    projectId: string;
+    instanceId: string;
+    /** url to check */
+    server: string;
+}
+export declare const CreateMysqlCheckRequest: S.Schema<CreateMysqlCheckRequest>;
+export type MysqlCheckChildResponse = MongodbCheckChildResponse;
+export declare const MysqlCheckChildResponse: S.Schema<MongodbCheckChildResponse>;
+export type MysqlCheckResponseMysqlChecksList = Array<MongodbCheckChildResponse>;
+export declare const MysqlCheckResponseMysqlChecksList: S.Schema<MysqlCheckResponseMysqlChecksList>;
+export interface MysqlCheckResponse {
+    message: string;
+    mysqlCheck?: MongodbCheckChildResponse;
+    mysqlChecks: MysqlCheckResponseMysqlChecksList;
+}
+export declare const MysqlCheckResponse: S.Schema<MysqlCheckResponse>;
+export interface CreateNetworkCheckRequest {
+    projectId: string;
+    instanceId: string;
+    /** network to check */
+    address: string;
+}
+export declare const CreateNetworkCheckRequest: S.Schema<CreateNetworkCheckRequest>;
+export interface NetworkCheckChildResponse {
+    address: string;
+    id: string;
+}
+export declare const NetworkCheckChildResponse: S.Schema<NetworkCheckChildResponse>;
+export type NetworkCheckResponseNetworkChecksList = Array<NetworkCheckChildResponse>;
+export declare const NetworkCheckResponseNetworkChecksList: S.Schema<NetworkCheckResponseNetworkChecksList>;
+export interface NetworkCheckResponse {
+    message: string;
+    networkCheck?: NetworkCheckChildResponse;
+    networkChecks: NetworkCheckResponseNetworkChecksList;
+}
+export declare const NetworkCheckResponse: S.Schema<NetworkCheckResponse>;
+export interface CreatePingCheckRequest {
+    projectId: string;
+    instanceId: string;
+    /** domain to check */
+    url: string;
+}
+export declare const CreatePingCheckRequest: S.Schema<CreatePingCheckRequest>;
+export type PingCheckChildResponse = HttpCheckChildResponse;
+export declare const PingCheckChildResponse: S.Schema<HttpCheckChildResponse>;
+export type PingCheckResponsePingChecksList = Array<HttpCheckChildResponse>;
+export declare const PingCheckResponsePingChecksList: S.Schema<PingCheckResponsePingChecksList>;
+export interface PingCheckResponse {
+    message: string;
+    pingCheck?: HttpCheckChildResponse;
+    pingChecks: PingCheckResponsePingChecksList;
+}
+export declare const PingCheckResponse: S.Schema<PingCheckResponse>;
+export interface CreatePostgresqlCheckRequest {
+    projectId: string;
+    instanceId: string;
+    /** url to check */
+    address: string;
+}
+export declare const CreatePostgresqlCheckRequest: S.Schema<CreatePostgresqlCheckRequest>;
+export type PostgresqlCheckChildResponse = NetworkCheckChildResponse;
+export declare const PostgresqlCheckChildResponse: S.Schema<NetworkCheckChildResponse>;
+export type PostgresqlCheckResponsePostgresqlChecksList = Array<NetworkCheckChildResponse>;
+export declare const PostgresqlCheckResponsePostgresqlChecksList: S.Schema<PostgresqlCheckResponsePostgresqlChecksList>;
+export interface PostgresqlCheckResponse {
+    message: string;
+    postgresqlCheck?: NetworkCheckChildResponse;
+    postgresqlChecks: PostgresqlCheckResponsePostgresqlChecksList;
+}
+export declare const PostgresqlCheckResponse: S.Schema<PostgresqlCheckResponse>;
+export interface CreateRabbitmqCheckRequest {
+    projectId: string;
+    instanceId: string;
+    /** password */
+    password?: string | Redacted.Redacted<string>;
+    /** url to check */
+    url: string;
+    /** username */
+    username?: string;
+}
+export declare const CreateRabbitmqCheckRequest: S.Schema<CreateRabbitmqCheckRequest>;
+export interface RabbitMQCheckChildResponse {
+    id: string;
+    password?: string | Redacted.Redacted<string>;
+    url: string;
+    username?: string;
+}
+export declare const RabbitMQCheckChildResponse: S.Schema<RabbitMQCheckChildResponse>;
+export type RabbitmqCheckResponseRabbitmqChecksList = Array<RabbitMQCheckChildResponse>;
+export declare const RabbitmqCheckResponseRabbitmqChecksList: S.Schema<RabbitmqCheckResponseRabbitmqChecksList>;
+export interface RabbitmqCheckResponse {
+    message: string;
+    rabbitmqCheck?: RabbitMQCheckChildResponse;
+    rabbitmqChecks: RabbitmqCheckResponseRabbitmqChecksList;
+}
+export declare const RabbitmqCheckResponse: S.Schema<RabbitmqCheckResponse>;
+export interface CreateRedisCheckRequest {
+    projectId: string;
+    instanceId: string;
+    /** password */
+    password?: string | Redacted.Redacted<string>;
+    /** url to check */
+    server: string;
+    /** username */
+    username?: string;
+}
+export declare const CreateRedisCheckRequest: S.Schema<CreateRedisCheckRequest>;
+export type RedisCheckChildResponse = ElasticsearchCheckChildResponse;
+export declare const RedisCheckChildResponse: S.Schema<ElasticsearchCheckChildResponse>;
+export type RedisCheckResponseRedisChecksList = Array<ElasticsearchCheckChildResponse>;
+export declare const RedisCheckResponseRedisChecksList: S.Schema<RedisCheckResponseRedisChecksList>;
+export interface RedisCheckResponse {
+    message: string;
+    redisCheck?: ElasticsearchCheckChildResponse;
+    redisChecks: RedisCheckResponseRedisChecksList;
+}
+export declare const RedisCheckResponse: S.Schema<RedisCheckResponse>;
+/** Sets the 'Authorization' header on every scrape request with the configured username and password. `Additional Validators:` * if basicAuth is in the body no other authentication method should be in the body */
+export interface CreateScrapeConfigRequestBasicAuth {
+    /** password */
+    password?: string | Redacted.Redacted<string>;
+    /** username */
+    username?: string;
+}
+export declare const CreateScrapeConfigRequestBasicAuth: S.Schema<CreateScrapeConfigRequestBasicAuth>;
+/** Sets the 'Authorization' header on every scrape request with the configured username and password. `Additional Validators:` * if basicAuth is in the body no other authentication method should be in the body */
+export type CreateScrapeConfigRequestHttpSdConfigsItemBasicAuth = CreateScrapeConfigRequestBasicAuth;
+export declare const CreateScrapeConfigRequestHttpSdConfigsItemBasicAuth: S.Schema<CreateScrapeConfigRequestBasicAuth>;
+/** The URL to fetch the token from. */
+export type CreateScrapeConfigRequestHttpSdConfigsItemOauth2ScopesList = Array<string>;
+export declare const CreateScrapeConfigRequestHttpSdConfigsItemOauth2ScopesList: S.Schema<CreateScrapeConfigRequestHttpSdConfigsItemOauth2ScopesList>;
+/** Configures the scrape request's TLS settings. */
+export interface CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig {
+    /** Disable validation of the server certificate. */
+    insecureSkipVerify?: boolean;
+}
+export declare const CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig: S.Schema<CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig>;
+/** OAuth 2.0 authentication using the client credentials grant type. Prometheus fetches an access token from the specified endpoint with the given client access and secret keys. `Additional Validators:` * if oauth2 is in the body no other authentication method should be in the body */
+export interface CreateScrapeConfigRequestHttpSdConfigsItemOauth2 {
+    /** clientId */
+    clientId: string;
+    /** clientSecret */
+    clientSecret: string | Redacted.Redacted<string>;
+    /** The URL to fetch the token from. */
+    scopes?: CreateScrapeConfigRequestHttpSdConfigsItemOauth2ScopesList;
+    /** Configures the scrape request's TLS settings. */
+    tlsConfig?: CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+    /** The URL to fetch the token from. */
+    tokenUrl: string;
+}
+export declare const CreateScrapeConfigRequestHttpSdConfigsItemOauth2: S.Schema<CreateScrapeConfigRequestHttpSdConfigsItemOauth2>;
+/** Configures the scrape request's TLS settings. */
+export type CreateScrapeConfigRequestHttpSdConfigsItemTlsConfig = CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+export declare const CreateScrapeConfigRequestHttpSdConfigsItemTlsConfig: S.Schema<CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig>;
+export interface CreateScrapeConfigRequestHttpSdConfigsItem {
+    /** Sets the 'Authorization' header on every scrape request with the configured username and password. `Additional Validators:` * if basicAuth is in the body no other authentication method should be in the body */
+    basicAuth?: CreateScrapeConfigRequestBasicAuth;
+    /** OAuth 2.0 authentication using the client credentials grant type. Prometheus fetches an access token from the specified endpoint with the given client access and secret keys. `Additional Validators:` * if oauth2 is in the body no other authentication method should be in the body */
+    oauth2?: CreateScrapeConfigRequestHttpSdConfigsItemOauth2;
+    /** Refresh interval to re-query the endpoint. E.g. 60s `Additional Validators:` * must be a valid time format* must be >= 60s */
+    refreshInterval?: string;
+    /** Configures the scrape request's TLS settings. */
+    tlsConfig?: CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+    /** URL from which the targets are fetched. */
+    url: string;
+}
+export declare const CreateScrapeConfigRequestHttpSdConfigsItem: S.Schema<CreateScrapeConfigRequestHttpSdConfigsItem>;
+/** HTTP-based service discovery provides a more generic way to configure static targets and serves as an interface to plug in custom service discovery mechanisms. */
+export type CreateScrapeConfigRequestHttpSdConfigsList = Array<CreateScrapeConfigRequestHttpSdConfigsItem>;
+export declare const CreateScrapeConfigRequestHttpSdConfigsList: S.Schema<CreateScrapeConfigRequestHttpSdConfigsList>;
+/** Action to perform based on regex matching. `Additional Validators:` * if action is replace, targetLabel needs to be in body */
+export type CreateScrapeConfigRequestMetricsRelabelConfigsItemAction = "replace" | "keep" | "drop" | "hashmod" | "labelmap" | "labeldrop" | "labelkeep";
+export declare const CreateScrapeConfigRequestMetricsRelabelConfigsItemAction: any;
+/** The source labels select values from existing labels. Their content is concatenated using the configured separator and matched against the configured regular expression for the replace, keep, and drop actions. */
+export type CreateScrapeConfigRequestMetricsRelabelConfigsItemSourceLabelsList = Array<string>;
+export declare const CreateScrapeConfigRequestMetricsRelabelConfigsItemSourceLabelsList: S.Schema<CreateScrapeConfigRequestMetricsRelabelConfigsItemSourceLabelsList>;
+export interface CreateScrapeConfigRequestMetricsRelabelConfigsItem {
+    /** Action to perform based on regex matching. `Additional Validators:` * if action is replace, targetLabel needs to be in body */
+    action?: CreateScrapeConfigRequestMetricsRelabelConfigsItemAction | (string & {});
+    /** Modulus to take of the hash of the source label values. */
+    modulus?: number;
+    /** Regular expression against which the extracted value is matched. */
+    regex?: string;
+    /** Replacement value against which a regex replace is performed if the regular expression matches. Regex capture groups are available. */
+    replacement?: string;
+    /** Separator placed between concatenated source label values. */
+    separator?: string;
+    /** The source labels select values from existing labels. Their content is concatenated using the configured separator and matched against the configured regular expression for the replace, keep, and drop actions. */
+    sourceLabels?: CreateScrapeConfigRequestMetricsRelabelConfigsItemSourceLabelsList;
+    /** Label to which the resulting value is written in a replace action. It is mandatory for replace actions. Regex capture groups are available. */
+    targetLabel?: string;
+}
+export declare const CreateScrapeConfigRequestMetricsRelabelConfigsItem: S.Schema<CreateScrapeConfigRequestMetricsRelabelConfigsItem>;
+/** List of metric relabel configurations */
+export type CreateScrapeConfigRequestMetricsRelabelConfigsList = Array<CreateScrapeConfigRequestMetricsRelabelConfigsItem>;
+export declare const CreateScrapeConfigRequestMetricsRelabelConfigsList: S.Schema<CreateScrapeConfigRequestMetricsRelabelConfigsList>;
+/** The URL to fetch the token from. */
+export type CreateScrapeConfigRequestOauth2ScopesList = Array<string>;
+export declare const CreateScrapeConfigRequestOauth2ScopesList: S.Schema<CreateScrapeConfigRequestOauth2ScopesList>;
+/** Configures the scrape request's TLS settings. */
+export type CreateScrapeConfigRequestOauth2TlsConfig = CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+export declare const CreateScrapeConfigRequestOauth2TlsConfig: S.Schema<CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig>;
+/** OAuth 2.0 authentication using the client credentials grant type. Prometheus fetches an access token from the specified endpoint with the given client access and secret keys. `Additional Validators:` * if oauth2 is in the body no other authentication method should be in the body */
+export interface CreateScrapeConfigRequestOauth2 {
+    /** clientId */
+    clientId: string;
+    /** clientSecret */
+    clientSecret: string | Redacted.Redacted<string>;
+    /** The URL to fetch the token from. */
+    scopes?: CreateScrapeConfigRequestOauth2ScopesList;
+    /** Configures the scrape request's TLS settings. */
+    tlsConfig?: CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+    /** The URL to fetch the token from. */
+    tokenUrl: string;
+}
+export declare const CreateScrapeConfigRequestOauth2: S.Schema<CreateScrapeConfigRequestOauth2>;
+/** Configures the protocol scheme used for requests. https or http */
+export type CreateScrapeConfigRequestScheme = "http" | "https";
+export declare const CreateScrapeConfigRequestScheme: any;
+/** The targets specified by the static config. */
+export type CreateScrapeConfigRequestStaticConfigsItemTargetsList = Array<string>;
+export declare const CreateScrapeConfigRequestStaticConfigsItemTargetsList: S.Schema<CreateScrapeConfigRequestStaticConfigsItemTargetsList>;
+export interface CreateScrapeConfigRequestStaticConfigsItem {
+    /** Labels assigned to all metrics scraped from the targets. `Additional Validators:` * should not contain more than 10 keys * each key and value should not be longer than 200 characters */
+    labels?: unknown;
+    /** The targets specified by the static config. */
+    targets: CreateScrapeConfigRequestStaticConfigsItemTargetsList;
+}
+export declare const CreateScrapeConfigRequestStaticConfigsItem: S.Schema<CreateScrapeConfigRequestStaticConfigsItem>;
+/** A list of scrape configurations. */
+export type CreateScrapeConfigRequestStaticConfigsList = Array<CreateScrapeConfigRequestStaticConfigsItem>;
+export declare const CreateScrapeConfigRequestStaticConfigsList: S.Schema<CreateScrapeConfigRequestStaticConfigsList>;
+/** Configures the scrape request's TLS settings. */
+export type CreateScrapeConfigRequestTlsConfig = CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+export declare const CreateScrapeConfigRequestTlsConfig: S.Schema<CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig>;
+export interface CreateScrapeConfigRequest {
+    projectId: string;
+    instanceId: string;
+    /** Sets the 'Authorization' header on every scrape request with the configured username and password. `Additional Validators:` * if basicAuth is in the body no other authentication method should be in the body */
+    basicAuth?: CreateScrapeConfigRequestBasicAuth;
+    /** Sets the 'Authorization' header on every scrape request with the configured bearer token. It is mutually exclusive with 'bearer_token_file'. `Additional Validators:` * needs to be a valid bearer token * if bearerToken is in the body no other authentication method should be in the body */
+    bearerToken?: string;
+    /** Note that any globally configured 'external_labels' are unaffected by this setting. In communication with external systems, they are always applied only when a time series does not have a given label yet and are ignored otherwise. */
+    honorLabels?: boolean;
+    /** honor_timestamps controls whether Prometheus respects the timestamps present in scraped data. If honor_timestamps is set to 'true', the timestamps of the metrics exposed by the target will be used. */
+    honorTimeStamps?: boolean;
+    /** HTTP-based service discovery provides a more generic way to configure static targets and serves as an interface to plug in custom service discovery mechanisms. */
+    httpSdConfigs?: CreateScrapeConfigRequestHttpSdConfigsList;
+    /** The job name assigned to scraped metrics by default. `Additional Validators:` * must be unique * key and values should only include the characters: a-zA-Z0-9- */
+    jobName: string;
+    /** The HTTP resource path on which to fetch metrics from targets. E.g. /metrics */
+    metricsPath?: string;
+    /** List of metric relabel configurations */
+    metricsRelabelConfigs?: CreateScrapeConfigRequestMetricsRelabelConfigsList;
+    /** OAuth 2.0 authentication using the client credentials grant type. Prometheus fetches an access token from the specified endpoint with the given client access and secret keys. `Additional Validators:` * if oauth2 is in the body no other authentication method should be in the body */
+    oauth2?: CreateScrapeConfigRequestOauth2;
+    /** Optional http params `Additional Validators:` * should not contain more than 5 keys * each key and value should not have more than 200 characters */
+    params?: unknown;
+    /** Per-scrape limit on number of scraped samples that will be accepted. If more than this number of samples are present after metric relabeling the entire scrape will be treated as failed. The total limit depends on the service plan target limits * samples */
+    sampleLimit?: number;
+    /** Configures the protocol scheme used for requests. https or http */
+    scheme: CreateScrapeConfigRequestScheme | (string & {});
+    /** How frequently to scrape targets from this job. E.g. 5m `Additional Validators:` * must be a valid time format* must be >= 60s */
+    scrapeInterval: string;
+    /** Per-scrape timeout when scraping this job. `Additional Validators:` * must be a valid time format* must be smaller than scrapeInterval */
+    scrapeTimeout: string;
+    /** A list of scrape configurations. */
+    staticConfigs: CreateScrapeConfigRequestStaticConfigsList;
+    /** Configures the scrape request's TLS settings. */
+    tlsConfig?: CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+}
+export declare const CreateScrapeConfigRequest: S.Schema<CreateScrapeConfigRequest>;
+export interface BasicAuth {
+    password: string | Redacted.Redacted<string>;
+    username: string;
+}
+export declare const BasicAuth: S.Schema<BasicAuth>;
+export type OAuth2ScopesList = Array<string>;
+export declare const OAuth2ScopesList: S.Schema<OAuth2ScopesList>;
+export interface TLSConfig {
+    insecureSkipVerify?: boolean;
+}
+export declare const TLSConfig: S.Schema<TLSConfig>;
+export interface OAuth2 {
+    clientId: string;
+    clientSecret: string | Redacted.Redacted<string>;
+    scopes?: OAuth2ScopesList;
+    tlsConfig?: TLSConfig;
+    tokenUrl: string;
+}
+export declare const OAuth2: S.Schema<OAuth2>;
+export interface HTTPServiceSD {
+    basicAuth?: BasicAuth;
+    oauth2?: OAuth2;
+    refreshInterval?: string;
+    tlsConfig?: TLSConfig;
+    url: string;
+}
+export declare const HTTPServiceSD: S.Schema<HTTPServiceSD>;
+export type JobHttpSdConfigsList = Array<HTTPServiceSD>;
+export declare const JobHttpSdConfigsList: S.Schema<JobHttpSdConfigsList>;
+export type MetricsRelabelConfigAction = "replace" | "keep" | "drop" | "hashmod" | "labelmap" | "labeldrop" | "labelkeep";
+export declare const MetricsRelabelConfigAction: any;
+export type MetricsRelabelConfigSourceLabelsList = Array<string>;
+export declare const MetricsRelabelConfigSourceLabelsList: S.Schema<MetricsRelabelConfigSourceLabelsList>;
+export interface MetricsRelabelConfig {
+    action?: MetricsRelabelConfigAction;
+    modulus?: number;
+    regex?: string;
+    replacement?: string;
+    separator?: string;
+    sourceLabels: MetricsRelabelConfigSourceLabelsList;
+    targetLabel?: string;
+}
+export declare const MetricsRelabelConfig: S.Schema<MetricsRelabelConfig>;
+export type JobMetricsRelabelConfigsList = Array<MetricsRelabelConfig>;
+export declare const JobMetricsRelabelConfigsList: S.Schema<JobMetricsRelabelConfigsList>;
+export type JobParamsValueList = Array<string>;
+export declare const JobParamsValueList: S.Schema<JobParamsValueList>;
+export type JobParamsMap = {
+    [key: string]: JobParamsValueList | undefined;
+};
+export declare const JobParamsMap: S.Schema<JobParamsMap>;
+export type JobScheme = "http" | "https";
+export declare const JobScheme: any;
+export type StaticConfigsLabelsMap = {
+    [key: string]: string | undefined;
+};
+export declare const StaticConfigsLabelsMap: S.Schema<StaticConfigsLabelsMap>;
+export type StaticConfigsTargetsList = Array<string>;
+export declare const StaticConfigsTargetsList: S.Schema<StaticConfigsTargetsList>;
+export interface StaticConfigs {
+    labels?: StaticConfigsLabelsMap;
+    targets: StaticConfigsTargetsList;
+}
+export declare const StaticConfigs: S.Schema<StaticConfigs>;
+export type JobStaticConfigsList = Array<StaticConfigs>;
+export declare const JobStaticConfigsList: S.Schema<JobStaticConfigsList>;
+export interface Job {
+    basicAuth?: BasicAuth;
+    bearerToken?: string;
+    honorLabels?: boolean;
+    honorTimeStamps?: boolean;
+    httpSdConfigs?: JobHttpSdConfigsList;
+    jobName: string;
+    metricsPath?: string;
+    metricsRelabelConfigs?: JobMetricsRelabelConfigsList;
+    oauth2?: OAuth2;
+    params?: JobParamsMap;
+    sampleLimit?: number;
+    scheme?: JobScheme;
+    scrapeInterval: string;
+    scrapeTimeout: string;
+    staticConfigs: JobStaticConfigsList;
+    tlsConfig?: TLSConfig;
+}
+export declare const Job: S.Schema<Job>;
+export type ScrapeConfigsResponseDataList = Array<Job>;
+export declare const ScrapeConfigsResponseDataList: S.Schema<ScrapeConfigsResponseDataList>;
+export interface ScrapeConfigsResponse {
+    data: ScrapeConfigsResponseDataList;
+    message: string;
+}
+export declare const ScrapeConfigsResponse: S.Schema<ScrapeConfigsResponse>;
+export interface DeleteAlertConfigReceiverRequest {
+    projectId: string;
+    instanceId: string;
+    receiver: string;
+}
+export declare const DeleteAlertConfigReceiverRequest: S.Schema<DeleteAlertConfigReceiverRequest>;
+export interface DeleteAlertConfigRouteRequest {
+    projectId: string;
+    instanceId: string;
+    receiver: string;
+}
+export declare const DeleteAlertConfigRouteRequest: S.Schema<DeleteAlertConfigRouteRequest>;
+export interface DeleteAlertgroupRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+}
+export declare const DeleteAlertgroupRequest: S.Schema<DeleteAlertgroupRequest>;
+export type DeleteAlertgroupsRequestGroupNameList = Array<string>;
+export declare const DeleteAlertgroupsRequestGroupNameList: S.Schema<DeleteAlertgroupsRequestGroupNameList>;
+export interface DeleteAlertgroupsRequest {
+    projectId: string;
+    instanceId: string;
+    /** Name of the groups that should be deleted */
+    groupName: DeleteAlertgroupsRequestGroupNameList;
+}
+export declare const DeleteAlertgroupsRequest: S.Schema<DeleteAlertgroupsRequest>;
+export interface DeleteAlertRecordRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+    alertRecord: string;
+}
+export declare const DeleteAlertRecordRequest: S.Schema<DeleteAlertRecordRequest>;
+export type DeleteAlertRecordsRequestAlertRecordList = Array<string>;
+export declare const DeleteAlertRecordsRequestAlertRecordList: S.Schema<DeleteAlertRecordsRequestAlertRecordList>;
+export interface DeleteAlertRecordsRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+    /** Name of the records that should be deleted */
+    alertRecord: DeleteAlertRecordsRequestAlertRecordList;
+}
+export declare const DeleteAlertRecordsRequest: S.Schema<DeleteAlertRecordsRequest>;
+export interface DeleteAlertruleRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+    alertName: string;
+}
+export declare const DeleteAlertruleRequest: S.Schema<DeleteAlertruleRequest>;
+export type DeleteAlertrulesRequestAlertNameList = Array<string>;
+export declare const DeleteAlertrulesRequestAlertNameList: S.Schema<DeleteAlertrulesRequestAlertNameList>;
+export interface DeleteAlertrulesRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+    /** Name of the alert rules that should be deleted */
+    alertName: DeleteAlertrulesRequestAlertNameList;
+}
+export declare const DeleteAlertrulesRequest: S.Schema<DeleteAlertrulesRequest>;
+export interface DeleteCertCheckRequest {
+    projectId: string;
+    instanceId: string;
+    id: string;
+}
+export declare const DeleteCertCheckRequest: S.Schema<DeleteCertCheckRequest>;
+export interface DeleteCredentialsRequest {
+    projectId: string;
+    instanceId: string;
+    username: string;
+}
+export declare const DeleteCredentialsRequest: S.Schema<DeleteCredentialsRequest>;
+export interface DeleteCredentialsRemoteWriteConfigRequest {
+    projectId: string;
+    instanceId: string;
+    username: string;
+}
+export declare const DeleteCredentialsRemoteWriteConfigRequest: S.Schema<DeleteCredentialsRemoteWriteConfigRequest>;
+export interface CredentialsRemoteWriteDeleteResponse {
+    maxLimit: number;
+    message: string;
+}
+export declare const CredentialsRemoteWriteDeleteResponse: S.Schema<CredentialsRemoteWriteDeleteResponse>;
+export interface DeleteElasticsearchCheckRequest {
+    projectId: string;
+    instanceId: string;
+    id: string;
+}
+export declare const DeleteElasticsearchCheckRequest: S.Schema<DeleteElasticsearchCheckRequest>;
+export interface DeleteHttpCheckRequest {
+    projectId: string;
+    instanceId: string;
+    id: string;
+}
+export declare const DeleteHttpCheckRequest: S.Schema<DeleteHttpCheckRequest>;
+export interface DeleteInstanceRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const DeleteInstanceRequest: S.Schema<DeleteInstanceRequest>;
+export interface InstanceResponse {
+    message: string;
+}
+export declare const InstanceResponse: S.Schema<InstanceResponse>;
+export interface DeleteLogsAlertgroupRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+}
+export declare const DeleteLogsAlertgroupRequest: S.Schema<DeleteLogsAlertgroupRequest>;
+export interface DeleteMongodbCheckRequest {
+    projectId: string;
+    instanceId: string;
+    id: string;
+}
+export declare const DeleteMongodbCheckRequest: S.Schema<DeleteMongodbCheckRequest>;
+export interface DeleteMysqlCheckRequest {
+    projectId: string;
+    instanceId: string;
+    id: string;
+}
+export declare const DeleteMysqlCheckRequest: S.Schema<DeleteMysqlCheckRequest>;
+export interface DeleteNetworkCheckRequest {
+    projectId: string;
+    instanceId: string;
+    id: string;
+}
+export declare const DeleteNetworkCheckRequest: S.Schema<DeleteNetworkCheckRequest>;
+export interface DeletePingCheckRequest {
+    projectId: string;
+    instanceId: string;
+    id: string;
+}
+export declare const DeletePingCheckRequest: S.Schema<DeletePingCheckRequest>;
+export interface DeletePostgresqlCheckRequest {
+    projectId: string;
+    instanceId: string;
+    id: string;
+}
+export declare const DeletePostgresqlCheckRequest: S.Schema<DeletePostgresqlCheckRequest>;
+export interface DeleteRabbitmqCheckRequest {
+    projectId: string;
+    instanceId: string;
+    id: string;
+}
+export declare const DeleteRabbitmqCheckRequest: S.Schema<DeleteRabbitmqCheckRequest>;
+export interface DeleteRedisCheckRequest {
+    projectId: string;
+    instanceId: string;
+    id: string;
+}
+export declare const DeleteRedisCheckRequest: S.Schema<DeleteRedisCheckRequest>;
+export interface DeleteScrapeConfigRequest {
+    projectId: string;
+    instanceId: string;
+    jobName: string;
+}
+export declare const DeleteScrapeConfigRequest: S.Schema<DeleteScrapeConfigRequest>;
+export type DeleteScrapeConfigResponseDataList = Array<Job>;
+export declare const DeleteScrapeConfigResponseDataList: S.Schema<DeleteScrapeConfigResponseDataList>;
+export interface DeleteScrapeConfigResponse {
+    data: DeleteScrapeConfigResponseDataList;
+    message: string;
+}
+export declare const DeleteScrapeConfigResponse: S.Schema<DeleteScrapeConfigResponse>;
+export type DeleteScrapeConfigsRequestJobNameList = Array<string>;
+export declare const DeleteScrapeConfigsRequestJobNameList: S.Schema<DeleteScrapeConfigsRequestJobNameList>;
+export interface DeleteScrapeConfigsRequest {
+    projectId: string;
+    instanceId: string;
+    /** Name of the jobs that should be deleted */
+    jobName: DeleteScrapeConfigsRequestJobNameList;
+}
+export declare const DeleteScrapeConfigsRequest: S.Schema<DeleteScrapeConfigsRequest>;
+export interface GetAlertConfigReceiverRequest {
+    projectId: string;
+    instanceId: string;
+    receiver: string;
+}
+export declare const GetAlertConfigReceiverRequest: S.Schema<GetAlertConfigReceiverRequest>;
+export interface Receiver {
+    data: Receivers;
+    message: string;
+}
+export declare const Receiver: S.Schema<Receiver>;
+export interface GetAlertConfigRouteRequest {
+    projectId: string;
+    instanceId: string;
+    receiver: string;
+}
+export declare const GetAlertConfigRouteRequest: S.Schema<GetAlertConfigRouteRequest>;
+export interface GetAlertConfigsRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const GetAlertConfigsRequest: S.Schema<GetAlertConfigsRequest>;
+export interface Global {
+    opsgenieApiKey?: string;
+    opsgenieApiUrl?: string;
+    resolveTimeout?: string;
+    smtpAuthIdentity?: string;
+    smtpAuthPassword?: string | Redacted.Redacted<string>;
+    smtpAuthUsername?: string;
+    smtpFrom?: string;
+    smtpSmarthost?: string;
+}
+export declare const Global: S.Schema<Global>;
+export type InhibitRulesEqualList = Array<string>;
+export declare const InhibitRulesEqualList: S.Schema<InhibitRulesEqualList>;
+export type InhibitRulesSourceMatchMap = {
+    [key: string]: string | undefined;
+};
+export declare const InhibitRulesSourceMatchMap: S.Schema<InhibitRulesSourceMatchMap>;
+export type InhibitRulesSourceMatchReMap = {
+    [key: string]: string | undefined;
+};
+export declare const InhibitRulesSourceMatchReMap: S.Schema<InhibitRulesSourceMatchReMap>;
+export type InhibitRulesSourceMatchersList = Array<string>;
+export declare const InhibitRulesSourceMatchersList: S.Schema<InhibitRulesSourceMatchersList>;
+export type InhibitRulesTargetMatchMap = {
+    [key: string]: string | undefined;
+};
+export declare const InhibitRulesTargetMatchMap: S.Schema<InhibitRulesTargetMatchMap>;
+export type InhibitRulesTargetMatchReMap = {
+    [key: string]: string | undefined;
+};
+export declare const InhibitRulesTargetMatchReMap: S.Schema<InhibitRulesTargetMatchReMap>;
+export type InhibitRulesTargetMatchersList = Array<string>;
+export declare const InhibitRulesTargetMatchersList: S.Schema<InhibitRulesTargetMatchersList>;
+export interface InhibitRules {
+    equal?: InhibitRulesEqualList;
+    sourceMatch?: InhibitRulesSourceMatchMap;
+    sourceMatchRe?: InhibitRulesSourceMatchReMap;
+    sourceMatchers?: InhibitRulesSourceMatchersList;
+    targetMatch?: InhibitRulesTargetMatchMap;
+    targetMatchRe?: InhibitRulesTargetMatchReMap;
+    targetMatchers?: InhibitRulesTargetMatchersList;
+}
+export declare const InhibitRules: S.Schema<InhibitRules>;
+export type AlertInhibitRulesList = Array<InhibitRules>;
+export declare const AlertInhibitRulesList: S.Schema<AlertInhibitRulesList>;
+export type AlertReceiversList = Array<Receivers>;
+export declare const AlertReceiversList: S.Schema<AlertReceiversList>;
+export interface Alert {
+    global?: Global;
+    inhibitRules?: AlertInhibitRulesList;
+    receivers: AlertReceiversList;
+    route: Route;
+}
+export declare const Alert: S.Schema<Alert>;
+export interface GetAlertConfigsResponse {
+    data: Alert;
+    message: string;
+}
+export declare const GetAlertConfigsResponse: S.Schema<GetAlertConfigsResponse>;
+export interface GetAlertgroupRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+}
+export declare const GetAlertgroupRequest: S.Schema<GetAlertgroupRequest>;
+export interface AlertGroupResponse {
+    data: AlertGroup;
+    message: string;
+}
+export declare const AlertGroupResponse: S.Schema<AlertGroupResponse>;
+export interface GetAlertRecordRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+    alertRecord: string;
+}
+export declare const GetAlertRecordRequest: S.Schema<GetAlertRecordRequest>;
+export interface AlertRecordResponse {
+    data: AlertRecord;
+    message: string;
+}
+export declare const AlertRecordResponse: S.Schema<AlertRecordResponse>;
+export interface GetAlertruleRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+    alertName: string;
+}
+export declare const GetAlertruleRequest: S.Schema<GetAlertruleRequest>;
+export interface AlertRuleResponse {
+    data: AlertRule;
+    message: string;
+}
+export declare const AlertRuleResponse: S.Schema<AlertRuleResponse>;
+export interface GetCredentialsRequest {
+    projectId: string;
+    instanceId: string;
+    username: string;
+}
+export declare const GetCredentialsRequest: S.Schema<GetCredentialsRequest>;
+export type GetCredentialsResponseCredentialsInfoMap = {
+    [key: string]: string | undefined;
+};
+export declare const GetCredentialsResponseCredentialsInfoMap: S.Schema<GetCredentialsResponseCredentialsInfoMap>;
+export interface GetCredentialsResponse {
+    credentialsInfo?: GetCredentialsResponseCredentialsInfoMap;
+    id: string;
+    message: string;
+    name: string;
+}
+export declare const GetCredentialsResponse: S.Schema<GetCredentialsResponse>;
+export interface GetCredentialsRemoteWriteConfigRequest {
+    projectId: string;
+    instanceId: string;
+    username: string;
+}
+export declare const GetCredentialsRemoteWriteConfigRequest: S.Schema<GetCredentialsRemoteWriteConfigRequest>;
+export interface CredentialsRemoteWriteConfig {
+    credentialsMaxLimit: number;
+    maxLimit: number;
+    message: string;
+}
+export declare const CredentialsRemoteWriteConfig: S.Schema<CredentialsRemoteWriteConfig>;
+export interface GetGrafanaConfigsRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const GetGrafanaConfigsRequest: S.Schema<GetGrafanaConfigsRequest>;
+export interface GrafanaOauth {
+    allowAssignGrafanaAdmin?: boolean;
+    apiUrl: string;
+    authUrl: string;
+    enabled: boolean;
+    name?: string;
+    oauthClientId: string;
+    oauthClientSecret: string;
+    roleAttributePath: string;
+    roleAttributeStrict?: boolean;
+    scopes?: string;
+    tokenUrl: string;
+    usePkce?: boolean;
+}
+export declare const GrafanaOauth: S.Schema<GrafanaOauth>;
+export interface GrafanaConfigs {
+    genericOauth?: GrafanaOauth;
+    message: string;
+    publicReadAccess?: boolean;
+    useStackitSso?: boolean;
+}
+export declare const GrafanaConfigs: S.Schema<GrafanaConfigs>;
+export interface GetInstanceRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const GetInstanceRequest: S.Schema<GetInstanceRequest>;
+export interface PlanModel {
+    alertMatchers: number;
+    alertReceivers: number;
+    alertRules: number;
+    amount?: number;
+    bucketSize: number;
+    description?: string;
+    grafanaGlobalDashboards: number;
+    grafanaGlobalOrgs: number;
+    grafanaGlobalSessions: number;
+    grafanaGlobalUsers: number;
+    id: string;
+    logsAlert: number;
+    logsStorage: number;
+    name?: string;
+    planId: string;
+    samplesPerScrape: number;
+    targetNumber: number;
+    totalMetricSamples: number;
+    tracesStorage: number;
+}
+export declare const PlanModel: S.Schema<PlanModel>;
+export interface InstanceSensitiveData {
+    alertingUrl: string;
+    cluster: string;
+    grafanaAdminEnabled: boolean;
+    grafanaAdminPassword?: string | Redacted.Redacted<string>;
+    grafanaAdminUser?: string;
+    grafanaPublicReadAccess: boolean;
+    grafanaUrl: string;
+    grafanaUseStackitSso: boolean;
+    instance: string;
+    jaegerHttpTracesUrl?: string;
+    jaegerHttpUrl: string;
+    jaegerTracesUrl: string;
+    jaegerUiUrl: string;
+    logsPushUrl: string;
+    logsUrl: string;
+    metricsEndpointUrl: string;
+    metricsRetentionTime1h: number;
+    metricsRetentionTime5m: number;
+    metricsRetentionTimeRaw: number;
+    metricsUrl: string;
+    name?: string;
+    otlpGrpcTracesUrl: string;
+    otlpHttpLogsUrl: string;
+    otlpHttpTracesUrl: string;
+    otlpTracesUrl: string;
+    plan: PlanModel;
+    pushMetricsUrl: string;
+    targetsUrl: string;
+    zipkinSpansUrl: string;
+}
+export declare const InstanceSensitiveData: S.Schema<InstanceSensitiveData>;
+export type GetInstanceResponseParametersMap = {
+    [key: string]: string | undefined;
+};
+export declare const GetInstanceResponseParametersMap: S.Schema<GetInstanceResponseParametersMap>;
+export type GetInstanceResponseStatus = "CREATING" | "CREATE_SUCCEEDED" | "CREATE_FAILED" | "DELETING" | "DELETE_SUCCEEDED" | "DELETE_FAILED" | "UPDATING" | "UPDATE_SUCCEEDED" | "UPDATE_FAILED";
+export declare const GetInstanceResponseStatus: any;
+export interface GetInstanceResponse {
+    dashboardUrl: string;
+    error?: string | null;
+    id: string;
+    instance: InstanceSensitiveData;
+    isUpdatable?: boolean;
+    message: string;
+    name?: string;
+    parameters?: GetInstanceResponseParametersMap;
+    planId: string;
+    planName: string;
+    planSchema?: string;
+    serviceName: string;
+    status: GetInstanceResponseStatus;
+}
+export declare const GetInstanceResponse: S.Schema<GetInstanceResponse>;
+export interface GetLogsAlertgroupRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+}
+export declare const GetLogsAlertgroupRequest: S.Schema<GetLogsAlertgroupRequest>;
+export interface GetLogsConfigsRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const GetLogsConfigsRequest: S.Schema<GetLogsConfigsRequest>;
+export interface LogsConfig {
+    retention: string;
+}
+export declare const LogsConfig: S.Schema<LogsConfig>;
+export interface LogsConfigResponse {
+    config: LogsConfig;
+    message: string;
+}
+export declare const LogsConfigResponse: S.Schema<LogsConfigResponse>;
+export interface GetMetricsStorageRetentionRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const GetMetricsStorageRetentionRequest: S.Schema<GetMetricsStorageRetentionRequest>;
+export interface GetMetricsStorageRetentionResponse {
+    message: string;
+    metricsRetentionTime1h: string;
+    metricsRetentionTime5m: string;
+    metricsRetentionTimeRaw: string;
+}
+export declare const GetMetricsStorageRetentionResponse: S.Schema<GetMetricsStorageRetentionResponse>;
+export interface GetScrapeConfigRequest {
+    projectId: string;
+    instanceId: string;
+    jobName: string;
+}
+export declare const GetScrapeConfigRequest: S.Schema<GetScrapeConfigRequest>;
+export interface GetScrapeConfigResponse {
+    data: Job;
+    message: string;
+}
+export declare const GetScrapeConfigResponse: S.Schema<GetScrapeConfigResponse>;
+export interface GetTracesConfigsRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const GetTracesConfigsRequest: S.Schema<GetTracesConfigsRequest>;
+export type TraceConfig = LogsConfig;
+export declare const TraceConfig: S.Schema<LogsConfig>;
+export interface TracesConfigResponse {
+    config: LogsConfig;
+    message: string;
+}
+export declare const TracesConfigResponse: S.Schema<TracesConfigResponse>;
+export interface ListACLRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListACLRequest: S.Schema<ListACLRequest>;
+export type ListACLResponseAclList = Array<string>;
+export declare const ListACLResponseAclList: S.Schema<ListACLResponseAclList>;
+export interface ListACLResponse {
+    acl: ListACLResponseAclList;
+    message: string;
+}
+export declare const ListACLResponse: S.Schema<ListACLResponse>;
+export interface ListAlertConfigReceiversRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListAlertConfigReceiversRequest: S.Schema<ListAlertConfigReceiversRequest>;
+export interface ListAlertConfigRoutesRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListAlertConfigRoutesRequest: S.Schema<ListAlertConfigRoutesRequest>;
+export interface ListAlertgroupsRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListAlertgroupsRequest: S.Schema<ListAlertgroupsRequest>;
+export interface ListAlertRecordsRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+}
+export declare const ListAlertRecordsRequest: S.Schema<ListAlertRecordsRequest>;
+export interface ListAlertrulesRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+}
+export declare const ListAlertrulesRequest: S.Schema<ListAlertrulesRequest>;
+export interface ListBackupRetentionsRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListBackupRetentionsRequest: S.Schema<ListBackupRetentionsRequest>;
+export interface BackupRetentionResponse {
+    alertConfigBackupRetention: string;
+    alertRulesBackupRetention: string;
+    grafanaBackupRetention: string;
+    message: string;
+    scrapeConfigBackupRetention: string;
+}
+export declare const BackupRetentionResponse: S.Schema<BackupRetentionResponse>;
+export type ListBackupsRequestBackupTargetItem = "alertConfig" | "alertRules" | "scrapeConfig" | "grafana";
+export declare const ListBackupsRequestBackupTargetItem: any;
+export type ListBackupsRequestBackupTargetList = Array<ListBackupsRequestBackupTargetItem | (string & {})>;
+export declare const ListBackupsRequestBackupTargetList: S.Schema<ListBackupsRequestBackupTargetList>;
+export interface ListBackupsRequest {
+    projectId: string;
+    instanceId: string;
+    /** List of backup targets */
+    backupTarget?: ListBackupsRequestBackupTargetList;
+}
+export declare const ListBackupsRequest: S.Schema<ListBackupsRequest>;
+export type BackupResponseAlertConfigBackupsList = Array<string>;
+export declare const BackupResponseAlertConfigBackupsList: S.Schema<BackupResponseAlertConfigBackupsList>;
+export type BackupResponseAlertRulesBackupsList = Array<string>;
+export declare const BackupResponseAlertRulesBackupsList: S.Schema<BackupResponseAlertRulesBackupsList>;
+export type BackupResponseGrafanaBackupsList = Array<string>;
+export declare const BackupResponseGrafanaBackupsList: S.Schema<BackupResponseGrafanaBackupsList>;
+export type BackupResponseScrapeConfigBackupsList = Array<string>;
+export declare const BackupResponseScrapeConfigBackupsList: S.Schema<BackupResponseScrapeConfigBackupsList>;
+export interface BackupResponse {
+    alertConfigBackups: BackupResponseAlertConfigBackupsList;
+    alertRulesBackups: BackupResponseAlertRulesBackupsList;
+    grafanaBackups: BackupResponseGrafanaBackupsList;
+    message: string;
+    scrapeConfigBackups: BackupResponseScrapeConfigBackupsList;
+}
+export declare const BackupResponse: S.Schema<BackupResponse>;
+export type ListBackupSchedulesRequestBackupTargetItem = "alertConfig" | "alertRules" | "scrapeConfig" | "grafana";
+export declare const ListBackupSchedulesRequestBackupTargetItem: any;
+export type ListBackupSchedulesRequestBackupTargetList = Array<ListBackupSchedulesRequestBackupTargetItem | (string & {})>;
+export declare const ListBackupSchedulesRequestBackupTargetList: S.Schema<ListBackupSchedulesRequestBackupTargetList>;
+export interface ListBackupSchedulesRequest {
+    projectId: string;
+    instanceId: string;
+    /** List of backup targets */
+    backupTarget?: ListBackupSchedulesRequestBackupTargetList;
+}
+export declare const ListBackupSchedulesRequest: S.Schema<ListBackupSchedulesRequest>;
+export interface BackupSchedule {
+    schedule: string;
+    scheduleId: string;
+}
+export declare const BackupSchedule: S.Schema<BackupSchedule>;
+export type BackupScheduleResponseAlertConfigBackupSchedulesList = Array<BackupSchedule>;
+export declare const BackupScheduleResponseAlertConfigBackupSchedulesList: S.Schema<BackupScheduleResponseAlertConfigBackupSchedulesList>;
+export type BackupScheduleResponseAlertRulesBackupSchedulesList = Array<BackupSchedule>;
+export declare const BackupScheduleResponseAlertRulesBackupSchedulesList: S.Schema<BackupScheduleResponseAlertRulesBackupSchedulesList>;
+export type BackupScheduleResponseGrafanaBackupSchedulesList = Array<BackupSchedule>;
+export declare const BackupScheduleResponseGrafanaBackupSchedulesList: S.Schema<BackupScheduleResponseGrafanaBackupSchedulesList>;
+export type BackupScheduleResponseScrapeConfigBackupSchedulesList = Array<BackupSchedule>;
+export declare const BackupScheduleResponseScrapeConfigBackupSchedulesList: S.Schema<BackupScheduleResponseScrapeConfigBackupSchedulesList>;
+export interface BackupScheduleResponse {
+    alertConfigBackupSchedules?: BackupScheduleResponseAlertConfigBackupSchedulesList;
+    alertRulesBackupSchedules?: BackupScheduleResponseAlertRulesBackupSchedulesList;
+    grafanaBackupSchedules?: BackupScheduleResponseGrafanaBackupSchedulesList;
+    message: string;
+    scrapeConfigBackupSchedules?: BackupScheduleResponseScrapeConfigBackupSchedulesList;
+}
+export declare const BackupScheduleResponse: S.Schema<BackupScheduleResponse>;
+export interface ListCertChecksRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListCertChecksRequest: S.Schema<ListCertChecksRequest>;
+export interface ListCredentialsRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListCredentialsRequest: S.Schema<ListCredentialsRequest>;
+export type ServiceKeysListCredentialsInfoMap = {
+    [key: string]: string | undefined;
+};
+export declare const ServiceKeysListCredentialsInfoMap: S.Schema<ServiceKeysListCredentialsInfoMap>;
+export interface ServiceKeysList {
+    credentialsInfo?: ServiceKeysListCredentialsInfoMap;
+    description?: string;
+    id: string;
+    name: string;
+}
+export declare const ServiceKeysList: S.Schema<ServiceKeysList>;
+export type ListCredentialsResponseCredentialsList = Array<ServiceKeysList>;
+export declare const ListCredentialsResponseCredentialsList: S.Schema<ListCredentialsResponseCredentialsList>;
+export interface ListCredentialsResponse {
+    credentials: ListCredentialsResponseCredentialsList;
+    message: string;
+}
+export declare const ListCredentialsResponse: S.Schema<ListCredentialsResponse>;
+export interface ListElasticsearchChecksRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListElasticsearchChecksRequest: S.Schema<ListElasticsearchChecksRequest>;
+export interface ListHttpChecksRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListHttpChecksRequest: S.Schema<ListHttpChecksRequest>;
+export interface ListInstancesRequest {
+    projectId: string;
+}
+export declare const ListInstancesRequest: S.Schema<ListInstancesRequest>;
+export type ProjectInstanceFullStatus = "CREATING" | "CREATE_SUCCEEDED" | "CREATE_FAILED" | "DELETING" | "DELETE_SUCCEEDED" | "DELETE_FAILED" | "UPDATING" | "UPDATE_SUCCEEDED" | "UPDATE_FAILED";
+export declare const ProjectInstanceFullStatus: any;
+export interface ProjectInstanceFull {
+    error?: string | null;
+    id: string;
+    instance: string;
+    name?: string;
+    planName: string;
+    serviceName: string;
+    status: ProjectInstanceFullStatus;
+}
+export declare const ProjectInstanceFull: S.Schema<ProjectInstanceFull>;
+export type ListInstancesResponseInstancesList = Array<ProjectInstanceFull>;
+export declare const ListInstancesResponseInstancesList: S.Schema<ListInstancesResponseInstancesList>;
+export interface ListInstancesResponse {
+    instances: ListInstancesResponseInstancesList;
+    message: string;
+}
+export declare const ListInstancesResponse: S.Schema<ListInstancesResponse>;
+export interface ListLogsAlertgroupsRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListLogsAlertgroupsRequest: S.Schema<ListLogsAlertgroupsRequest>;
+export interface ListMongodbChecksRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListMongodbChecksRequest: S.Schema<ListMongodbChecksRequest>;
+export interface ListMysqlChecksRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListMysqlChecksRequest: S.Schema<ListMysqlChecksRequest>;
+export interface ListNetworkChecksRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListNetworkChecksRequest: S.Schema<ListNetworkChecksRequest>;
+export interface ListOfferingsRequest {
+    projectId: string;
+}
+export declare const ListOfferingsRequest: S.Schema<ListOfferingsRequest>;
+export interface Plan {
+    alertMatchers: number;
+    alertReceivers: number;
+    alertRules: number;
+    amount?: number;
+    bucketSize: number;
+    description?: string;
+    grafanaGlobalDashboards: number;
+    grafanaGlobalOrgs: number;
+    grafanaGlobalSessions: number;
+    grafanaGlobalUsers: number;
+    id: string;
+    isFree?: boolean;
+    isPublic?: boolean;
+    logsAlert: number;
+    logsStorage: number;
+    name?: string;
+    planId: string;
+    samplesPerScrape: number;
+    schema?: string;
+    targetNumber: number;
+    totalMetricSamples: number;
+    tracesStorage: number;
+}
+export declare const Plan: S.Schema<Plan>;
+export type OfferingsPlansList = Array<Plan>;
+export declare const OfferingsPlansList: S.Schema<OfferingsPlansList>;
+export type OfferingsTagsList = Array<string>;
+export declare const OfferingsTagsList: S.Schema<OfferingsTagsList>;
+export interface Offerings {
+    description: string;
+    documentationUrl: string;
+    imageUrl: string;
+    name: string;
+    plans: OfferingsPlansList;
+    tags: OfferingsTagsList;
+}
+export declare const Offerings: S.Schema<Offerings>;
+export interface ListPingChecksRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListPingChecksRequest: S.Schema<ListPingChecksRequest>;
+export interface ListPlansRequest {
+    projectId: string;
+}
+export declare const ListPlansRequest: S.Schema<ListPlansRequest>;
+export type PlansResponsePlansList = Array<Plan>;
+export declare const PlansResponsePlansList: S.Schema<PlansResponsePlansList>;
+export interface PlansResponse {
+    message: string;
+    plans: PlansResponsePlansList;
+}
+export declare const PlansResponse: S.Schema<PlansResponse>;
+export interface ListPostgresqlChecksRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListPostgresqlChecksRequest: S.Schema<ListPostgresqlChecksRequest>;
+export interface ListRabbitmqChecksRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListRabbitmqChecksRequest: S.Schema<ListRabbitmqChecksRequest>;
+export interface ListRedisChecksRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListRedisChecksRequest: S.Schema<ListRedisChecksRequest>;
+export interface ListScrapeConfigsRequest {
+    projectId: string;
+    instanceId: string;
+}
+export declare const ListScrapeConfigsRequest: S.Schema<ListScrapeConfigsRequest>;
+export type ListScrapeConfigsResponseDataList = Array<Job>;
+export declare const ListScrapeConfigsResponseDataList: S.Schema<ListScrapeConfigsResponseDataList>;
+export interface ListScrapeConfigsResponse {
+    data: ListScrapeConfigsResponseDataList;
+    message: string;
+}
+export declare const ListScrapeConfigsResponse: S.Schema<ListScrapeConfigsResponse>;
+/** Rule definition. Must be either an Alerting Rule (using 'alert') or a Recording Rule (using 'record'). `Additional Validators:` * total config (all alert groups/rules) should not be bigger than 500000 characters as string since this the limitation of prometheus. */
+export type PartialUpdateAlertgroupsRequestBodyItemRulesItem = CreateAlertgroupsRequestRulesItem;
+export declare const PartialUpdateAlertgroupsRequestBodyItemRulesItem: S.Schema<CreateAlertgroupsRequestRulesItem>;
+/** rules for the alert group */
+export type PartialUpdateAlertgroupsRequestBodyItemRulesList = Array<CreateAlertgroupsRequestRulesItem>;
+export declare const PartialUpdateAlertgroupsRequestBodyItemRulesList: S.Schema<PartialUpdateAlertgroupsRequestBodyItemRulesList>;
+/** Alert group that should be created or updated. `Additional Validators:` * total config should not be bigger than 500000 characters as string since this the limitation of prometheus. */
+export interface PartialUpdateAlertgroupsRequestBodyItem {
+    /** How often rules in the group are evaluated. `Additional Validators:` * must be a valid time string * should be >=60s */
+    interval?: string;
+    /** The name of the group. Must be unique. `Additional Validators:` * is the identifier and so unique * should only include the characters: a-zA-Z0-9- */
+    name: string;
+    /** rules for the alert group */
+    rules: PartialUpdateAlertgroupsRequestBodyItemRulesList;
+}
+export declare const PartialUpdateAlertgroupsRequestBodyItem: S.Schema<PartialUpdateAlertgroupsRequestBodyItem>;
+/** Array of alert groups that should be created or updated */
+export type PartialUpdateAlertgroupsRequestBodyList = Array<PartialUpdateAlertgroupsRequestBodyItem>;
+export declare const PartialUpdateAlertgroupsRequestBodyList: S.Schema<PartialUpdateAlertgroupsRequestBodyList>;
+export interface PartialUpdateAlertgroupsRequest {
+    projectId: string;
+    instanceId: string;
+    body: PartialUpdateAlertgroupsRequestBodyList;
+}
+export declare const PartialUpdateAlertgroupsRequest: S.Schema<PartialUpdateAlertgroupsRequest>;
+/** Record. `Additional Validators:` * total config (all alert groups/rules/records) should not be bigger than 500000 characters as string since this the limitation of prometheus. */
+export interface PartialUpdateAlertRecordsRequestBodyItem {
+    /** The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. */
+    expr: string;
+    /** map of key:value. Labels to add or overwrite for each alert. `Additional Validators:` * should not contain more than 10 keys * each key and value should not be longer than 200 characters */
+    labels?: unknown;
+    /** The name of the record. `Additional Validators:` * is the identifier and so unique in the group */
+    record: string;
+}
+export declare const PartialUpdateAlertRecordsRequestBodyItem: S.Schema<PartialUpdateAlertRecordsRequestBodyItem>;
+/** Array of records that should be created or updated */
+export type PartialUpdateAlertRecordsRequestBodyList = Array<PartialUpdateAlertRecordsRequestBodyItem>;
+export declare const PartialUpdateAlertRecordsRequestBodyList: S.Schema<PartialUpdateAlertRecordsRequestBodyList>;
+export interface PartialUpdateAlertRecordsRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+    body: PartialUpdateAlertRecordsRequestBodyList;
+}
+export declare const PartialUpdateAlertRecordsRequest: S.Schema<PartialUpdateAlertRecordsRequest>;
+/** Alert rule. `Additional Validators:` * total config (all alert groups/rules) should not be bigger than 500000 characters as string since this the limitation of prometheus. */
+export interface PartialUpdateAlertrulesRequestBodyItem {
+    /** The name of the alert. `Additional Validators:` * is the identifier and so unique in the group * should only include the characters: a-zA-Z0-9- */
+    alert: string;
+    /** map of key:value. Annotations to add to each alert. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters */
+    annotations?: unknown;
+    /** The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. */
+    expr: string;
+    /** Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. `Additional Validators:` * must be a valid time string */
+    for?: string;
+    /** map of key:value. Labels to add or overwrite for each alert. `Additional Validators:` * should not contain more than 10 keys * each key and value should not be longer than 200 characters */
+    labels?: unknown;
+}
+export declare const PartialUpdateAlertrulesRequestBodyItem: S.Schema<PartialUpdateAlertrulesRequestBodyItem>;
+/** Array of alert rules that should be created or updated */
+export type PartialUpdateAlertrulesRequestBodyList = Array<PartialUpdateAlertrulesRequestBodyItem>;
+export declare const PartialUpdateAlertrulesRequestBodyList: S.Schema<PartialUpdateAlertrulesRequestBodyList>;
+export interface PartialUpdateAlertrulesRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+    body: PartialUpdateAlertrulesRequestBodyList;
+}
+export declare const PartialUpdateAlertrulesRequest: S.Schema<PartialUpdateAlertrulesRequest>;
+/** Sets the 'Authorization' header on every scrape request with the configured username and password. `Additional Validators:` * if basicAuth is in the body no other authentication method should be in the body */
+export type PartialUpdateScrapeConfigsRequestBodyItemBasicAuth = CreateScrapeConfigRequestBasicAuth;
+export declare const PartialUpdateScrapeConfigsRequestBodyItemBasicAuth: S.Schema<CreateScrapeConfigRequestBasicAuth>;
+/** Sets the 'Authorization' header on every scrape request with the configured username and password. `Additional Validators:` * if basicAuth is in the body no other authentication method should be in the body */
+export type PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItemBasicAuth = CreateScrapeConfigRequestBasicAuth;
+export declare const PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItemBasicAuth: S.Schema<CreateScrapeConfigRequestBasicAuth>;
+/** The URL to fetch the token from. */
+export type PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItemOauth2ScopesList = Array<string>;
+export declare const PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItemOauth2ScopesList: S.Schema<PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItemOauth2ScopesList>;
+/** Configures the scrape request's TLS settings. */
+export type PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItemOauth2TlsConfig = CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+export declare const PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItemOauth2TlsConfig: S.Schema<CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig>;
+/** OAuth 2.0 authentication using the client credentials grant type. Prometheus fetches an access token from the specified endpoint with the given client access and secret keys. `Additional Validators:` * if oauth2 is in the body no other authentication method should be in the body */
+export interface PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItemOauth2 {
+    /** clientId */
+    clientId: string;
+    /** clientSecret */
+    clientSecret: string | Redacted.Redacted<string>;
+    /** The URL to fetch the token from. */
+    scopes?: PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItemOauth2ScopesList;
+    /** Configures the scrape request's TLS settings. */
+    tlsConfig?: CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+    /** The URL to fetch the token from. */
+    tokenUrl: string;
+}
+export declare const PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItemOauth2: S.Schema<PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItemOauth2>;
+/** Configures the scrape request's TLS settings. */
+export type PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItemTlsConfig = CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+export declare const PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItemTlsConfig: S.Schema<CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig>;
+export interface PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItem {
+    /** Sets the 'Authorization' header on every scrape request with the configured username and password. `Additional Validators:` * if basicAuth is in the body no other authentication method should be in the body */
+    basicAuth?: CreateScrapeConfigRequestBasicAuth;
+    /** OAuth 2.0 authentication using the client credentials grant type. Prometheus fetches an access token from the specified endpoint with the given client access and secret keys. `Additional Validators:` * if oauth2 is in the body no other authentication method should be in the body */
+    oauth2?: PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItemOauth2;
+    /** Refresh interval to re-query the endpoint. E.g. 60s `Additional Validators:` * must be a valid time format* must be >= 60s */
+    refreshInterval?: string;
+    /** Configures the scrape request's TLS settings. */
+    tlsConfig?: CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+    /** URL from which the targets are fetched. */
+    url: string;
+}
+export declare const PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItem: S.Schema<PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItem>;
+/** HTTP-based service discovery provides a more generic way to configure static targets and serves as an interface to plug in custom service discovery mechanisms. */
+export type PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsList = Array<PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsItem>;
+export declare const PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsList: S.Schema<PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsList>;
+/** Action to perform based on regex matching. `Additional Validators:` * if action is replace, targetLabel needs to be in body */
+export type PartialUpdateScrapeConfigsRequestBodyItemMetricsRelabelConfigsItemAction = "replace" | "keep" | "drop" | "hashmod" | "labelmap" | "labeldrop" | "labelkeep";
+export declare const PartialUpdateScrapeConfigsRequestBodyItemMetricsRelabelConfigsItemAction: any;
+/** The source labels select values from existing labels. Their content is concatenated using the configured separator and matched against the configured regular expression for the replace, keep, and drop actions. */
+export type PartialUpdateScrapeConfigsRequestBodyItemMetricsRelabelConfigsItemSourceLabelsList = Array<string>;
+export declare const PartialUpdateScrapeConfigsRequestBodyItemMetricsRelabelConfigsItemSourceLabelsList: S.Schema<PartialUpdateScrapeConfigsRequestBodyItemMetricsRelabelConfigsItemSourceLabelsList>;
+export interface PartialUpdateScrapeConfigsRequestBodyItemMetricsRelabelConfigsItem {
+    /** Action to perform based on regex matching. `Additional Validators:` * if action is replace, targetLabel needs to be in body */
+    action?: PartialUpdateScrapeConfigsRequestBodyItemMetricsRelabelConfigsItemAction | (string & {});
+    /** Modulus to take of the hash of the source label values. */
+    modulus?: number;
+    /** Regular expression against which the extracted value is matched. */
+    regex?: string;
+    /** Replacement value against which a regex replace is performed if the regular expression matches. Regex capture groups are available. */
+    replacement?: string;
+    /** Separator placed between concatenated source label values. */
+    separator?: string;
+    /** The source labels select values from existing labels. Their content is concatenated using the configured separator and matched against the configured regular expression for the replace, keep, and drop actions. */
+    sourceLabels?: PartialUpdateScrapeConfigsRequestBodyItemMetricsRelabelConfigsItemSourceLabelsList;
+    /** Label to which the resulting value is written in a replace action. It is mandatory for replace actions. Regex capture groups are available. */
+    targetLabel?: string;
+}
+export declare const PartialUpdateScrapeConfigsRequestBodyItemMetricsRelabelConfigsItem: S.Schema<PartialUpdateScrapeConfigsRequestBodyItemMetricsRelabelConfigsItem>;
+/** List of metric relabel configurations */
+export type PartialUpdateScrapeConfigsRequestBodyItemMetricsRelabelConfigsList = Array<PartialUpdateScrapeConfigsRequestBodyItemMetricsRelabelConfigsItem>;
+export declare const PartialUpdateScrapeConfigsRequestBodyItemMetricsRelabelConfigsList: S.Schema<PartialUpdateScrapeConfigsRequestBodyItemMetricsRelabelConfigsList>;
+/** The URL to fetch the token from. */
+export type PartialUpdateScrapeConfigsRequestBodyItemOauth2ScopesList = Array<string>;
+export declare const PartialUpdateScrapeConfigsRequestBodyItemOauth2ScopesList: S.Schema<PartialUpdateScrapeConfigsRequestBodyItemOauth2ScopesList>;
+/** Configures the scrape request's TLS settings. */
+export type PartialUpdateScrapeConfigsRequestBodyItemOauth2TlsConfig = CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+export declare const PartialUpdateScrapeConfigsRequestBodyItemOauth2TlsConfig: S.Schema<CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig>;
+/** OAuth 2.0 authentication using the client credentials grant type. Prometheus fetches an access token from the specified endpoint with the given client access and secret keys. `Additional Validators:` * if oauth2 is in the body no other authentication method should be in the body */
+export interface PartialUpdateScrapeConfigsRequestBodyItemOauth2 {
+    /** clientId */
+    clientId: string;
+    /** clientSecret */
+    clientSecret: string | Redacted.Redacted<string>;
+    /** The URL to fetch the token from. */
+    scopes?: PartialUpdateScrapeConfigsRequestBodyItemOauth2ScopesList;
+    /** Configures the scrape request's TLS settings. */
+    tlsConfig?: CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+    /** The URL to fetch the token from. */
+    tokenUrl: string;
+}
+export declare const PartialUpdateScrapeConfigsRequestBodyItemOauth2: S.Schema<PartialUpdateScrapeConfigsRequestBodyItemOauth2>;
+/** Configures the protocol scheme used for requests. https or http */
+export type PartialUpdateScrapeConfigsRequestBodyItemScheme = "http" | "https";
+export declare const PartialUpdateScrapeConfigsRequestBodyItemScheme: any;
+/** The targets specified by the static config. */
+export type PartialUpdateScrapeConfigsRequestBodyItemStaticConfigsItemTargetsList = Array<string>;
+export declare const PartialUpdateScrapeConfigsRequestBodyItemStaticConfigsItemTargetsList: S.Schema<PartialUpdateScrapeConfigsRequestBodyItemStaticConfigsItemTargetsList>;
+export interface PartialUpdateScrapeConfigsRequestBodyItemStaticConfigsItem {
+    /** Labels assigned to all metrics scraped from the targets. `Additional Validators:` * should not contain more than 10 keys * each key and value should not be longer than 200 characters */
+    labels?: unknown;
+    /** The targets specified by the static config. */
+    targets: PartialUpdateScrapeConfigsRequestBodyItemStaticConfigsItemTargetsList;
+}
+export declare const PartialUpdateScrapeConfigsRequestBodyItemStaticConfigsItem: S.Schema<PartialUpdateScrapeConfigsRequestBodyItemStaticConfigsItem>;
+/** A list of scrape configurations. */
+export type PartialUpdateScrapeConfigsRequestBodyItemStaticConfigsList = Array<PartialUpdateScrapeConfigsRequestBodyItemStaticConfigsItem>;
+export declare const PartialUpdateScrapeConfigsRequestBodyItemStaticConfigsList: S.Schema<PartialUpdateScrapeConfigsRequestBodyItemStaticConfigsList>;
+/** Configures the scrape request's TLS settings. */
+export type PartialUpdateScrapeConfigsRequestBodyItemTlsConfig = CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+export declare const PartialUpdateScrapeConfigsRequestBodyItemTlsConfig: S.Schema<CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig>;
+export interface PartialUpdateScrapeConfigsRequestBodyItem {
+    /** Sets the 'Authorization' header on every scrape request with the configured username and password. `Additional Validators:` * if basicAuth is in the body no other authentication method should be in the body */
+    basicAuth?: CreateScrapeConfigRequestBasicAuth;
+    /** Sets the 'Authorization' header on every scrape request with the configured bearer token. It is mutually exclusive with 'bearer_token_file'. `Additional Validators:` * needs to be a valid bearer token * if bearerToken is in the body no other authentication method should be in the body */
+    bearerToken?: string;
+    /** Note that any globally configured 'external_labels' are unaffected by this setting. In communication with external systems, they are always applied only when a time series does not have a given label yet and are ignored otherwise. */
+    honorLabels?: boolean;
+    /** honor_timestamps controls whether Prometheus respects the timestamps present in scraped data. If honor_timestamps is set to 'true', the timestamps of the metrics exposed by the target will be used. */
+    honorTimeStamps?: boolean;
+    /** HTTP-based service discovery provides a more generic way to configure static targets and serves as an interface to plug in custom service discovery mechanisms. */
+    httpSdConfigs?: PartialUpdateScrapeConfigsRequestBodyItemHttpSdConfigsList;
+    /** The job name assigned to scraped metrics by default. `Additional Validators:` * must be unique * key and values should only include the characters: a-zA-Z0-9- */
+    jobName: string;
+    /** The HTTP resource path on which to fetch metrics from targets. E.g. /metrics */
+    metricsPath?: string;
+    /** List of metric relabel configurations */
+    metricsRelabelConfigs?: PartialUpdateScrapeConfigsRequestBodyItemMetricsRelabelConfigsList;
+    /** OAuth 2.0 authentication using the client credentials grant type. Prometheus fetches an access token from the specified endpoint with the given client access and secret keys. `Additional Validators:` * if oauth2 is in the body no other authentication method should be in the body */
+    oauth2?: PartialUpdateScrapeConfigsRequestBodyItemOauth2;
+    /** Optional http params `Additional Validators:` * should not contain more than 5 keys * each key and value should not have more than 200 characters */
+    params?: unknown;
+    /** Per-scrape limit on number of scraped samples that will be accepted. If more than this number of samples are present after metric relabeling the entire scrape will be treated as failed. The total limit depends on the service plan target limits * samples */
+    sampleLimit?: number;
+    /** Configures the protocol scheme used for requests. https or http */
+    scheme: PartialUpdateScrapeConfigsRequestBodyItemScheme | (string & {});
+    /** How frequently to scrape targets from this job. E.g. 5m `Additional Validators:` * must be a valid time format* must be >= 60s */
+    scrapeInterval: string;
+    /** Per-scrape timeout when scraping this job. `Additional Validators:` * must be a valid time format* must be smaller than scrapeInterval */
+    scrapeTimeout: string;
+    /** A list of scrape configurations. */
+    staticConfigs: PartialUpdateScrapeConfigsRequestBodyItemStaticConfigsList;
+    /** Configures the scrape request's TLS settings. */
+    tlsConfig?: CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+}
+export declare const PartialUpdateScrapeConfigsRequestBodyItem: S.Schema<PartialUpdateScrapeConfigsRequestBodyItem>;
+/** Array of jobs that should be created or updated */
+export type PartialUpdateScrapeConfigsRequestBodyList = Array<PartialUpdateScrapeConfigsRequestBodyItem>;
+export declare const PartialUpdateScrapeConfigsRequestBodyList: S.Schema<PartialUpdateScrapeConfigsRequestBodyList>;
+export interface PartialUpdateScrapeConfigsRequest {
+    projectId: string;
+    instanceId: string;
+    body: PartialUpdateScrapeConfigsRequestBodyList;
+}
+export declare const PartialUpdateScrapeConfigsRequest: S.Schema<PartialUpdateScrapeConfigsRequest>;
+export type RestoreBackupRequestRestoreTarget = "alertConfig" | "alertRules" | "scrapeConfig" | "grafana";
+export declare const RestoreBackupRequestRestoreTarget: any;
+export interface RestoreBackupRequest {
+    projectId: string;
+    instanceId: string;
+    backupDate: string;
+    /** List of restore targets */
+    restoreTarget: RestoreBackupRequestRestoreTarget | (string & {});
+}
+export declare const RestoreBackupRequest: S.Schema<RestoreBackupRequest>;
+/** list of cidr */
+export type UpdateACLRequestAclList = Array<string>;
+export declare const UpdateACLRequestAclList: S.Schema<UpdateACLRequestAclList>;
+export interface UpdateACLRequest {
+    projectId: string;
+    instanceId: string;
+    /** list of cidr */
+    acl: UpdateACLRequestAclList;
+}
+export declare const UpdateACLRequest: S.Schema<UpdateACLRequest>;
+export type UpdateAlertConfigReceiverRequestEmailConfigsItem = CreateAlertConfigReceiverRequestEmailConfigsItem;
+export declare const UpdateAlertConfigReceiverRequestEmailConfigsItem: S.Schema<CreateAlertConfigReceiverRequestEmailConfigsItem>;
+/** Email configurations */
+export type UpdateAlertConfigReceiverRequestEmailConfigsList = Array<CreateAlertConfigReceiverRequestEmailConfigsItem>;
+export declare const UpdateAlertConfigReceiverRequestEmailConfigsList: S.Schema<UpdateAlertConfigReceiverRequestEmailConfigsList>;
+export type UpdateAlertConfigReceiverRequestOpsgenieConfigsItem = CreateAlertConfigReceiverRequestOpsgenieConfigsItem;
+export declare const UpdateAlertConfigReceiverRequestOpsgenieConfigsItem: S.Schema<CreateAlertConfigReceiverRequestOpsgenieConfigsItem>;
+/** Configuration for ops genie. */
+export type UpdateAlertConfigReceiverRequestOpsgenieConfigsList = Array<CreateAlertConfigReceiverRequestOpsgenieConfigsItem>;
+export declare const UpdateAlertConfigReceiverRequestOpsgenieConfigsList: S.Schema<UpdateAlertConfigReceiverRequestOpsgenieConfigsList>;
+export type UpdateAlertConfigReceiverRequestWebHookConfigsItem = CreateAlertConfigReceiverRequestWebHookConfigsItem;
+export declare const UpdateAlertConfigReceiverRequestWebHookConfigsItem: S.Schema<CreateAlertConfigReceiverRequestWebHookConfigsItem>;
+export type UpdateAlertConfigReceiverRequestWebHookConfigsList = Array<CreateAlertConfigReceiverRequestWebHookConfigsItem>;
+export declare const UpdateAlertConfigReceiverRequestWebHookConfigsList: S.Schema<UpdateAlertConfigReceiverRequestWebHookConfigsList>;
+export interface UpdateAlertConfigReceiverRequest {
+    projectId: string;
+    instanceId: string;
+    receiver: string;
+    /** Email configurations */
+    emailConfigs?: UpdateAlertConfigReceiverRequestEmailConfigsList;
+    /** `Additional Validators:` * must be unique * should only include the characters: a-zA-Z0-9- */
+    name: string;
+    /** Configuration for ops genie. */
+    opsgenieConfigs?: UpdateAlertConfigReceiverRequestOpsgenieConfigsList;
+    webHookConfigs?: UpdateAlertConfigReceiverRequestWebHookConfigsList;
+}
+export declare const UpdateAlertConfigReceiverRequest: S.Schema<UpdateAlertConfigReceiverRequest>;
+/** The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. */
+export type UpdateAlertConfigRouteRequestGroupByList = Array<string>;
+export declare const UpdateAlertConfigRouteRequestGroupByList: S.Schema<UpdateAlertConfigRouteRequestGroupByList>;
+/** A list of matchers that an alert has to fulfill to match the node. A matcher is a string with a syntax inspired by PromQL and OpenMetrics. The syntax of a matcher consists of three tokens: * A valid Prometheus label name. * One of =, !=, =~, or !~. = means equals, != means that the strings are not equal, =~ is used for equality of regex expressions and !~ is used for un-equality of regex expressions. They have the same meaning as known from PromQL selectors. * A UTF-8 string, which may be enclosed in double quotes. Before or after each token, there may be any amount of whitespace. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters */
+export type UpdateAlertConfigRouteRequestMatchersList = Array<string>;
+export declare const UpdateAlertConfigRouteRequestMatchersList: S.Schema<UpdateAlertConfigRouteRequestMatchersList>;
+export type UpdateAlertConfigRouteRequestRoutesItemGroupByList = Array<string>;
+export declare const UpdateAlertConfigRouteRequestRoutesItemGroupByList: S.Schema<UpdateAlertConfigRouteRequestRoutesItemGroupByList>;
+/** As in one level above */
+export type UpdateAlertConfigRouteRequestRoutesItemMatchersList = Array<string>;
+export declare const UpdateAlertConfigRouteRequestRoutesItemMatchersList: S.Schema<UpdateAlertConfigRouteRequestRoutesItemMatchersList>;
+/** Another child routes */
+export type UpdateAlertConfigRouteRequestRoutesItemRoutesList = Array<unknown>;
+export declare const UpdateAlertConfigRouteRequestRoutesItemRoutesList: S.Schema<UpdateAlertConfigRouteRequestRoutesItemRoutesList>;
+/** As in one level above */
+export interface UpdateAlertConfigRouteRequestRoutesItem {
+    /** Whether an alert should continue matching subsequent sibling nodes. */
+    continue?: boolean;
+    groupBy?: UpdateAlertConfigRouteRequestRoutesItemGroupByList;
+    /** As in one level above */
+    groupInterval?: string;
+    /** As in one level above */
+    groupWait?: string;
+    /** As in one level above */
+    match?: unknown;
+    /** As in one level above */
+    matchRe?: unknown;
+    /** As in one level above */
+    matchers?: UpdateAlertConfigRouteRequestRoutesItemMatchersList;
+    /** As in one level above */
+    receiver?: string;
+    /** As in one level above */
+    repeatInterval?: string;
+    /** Another child routes */
+    routes?: UpdateAlertConfigRouteRequestRoutesItemRoutesList;
+}
+export declare const UpdateAlertConfigRouteRequestRoutesItem: S.Schema<UpdateAlertConfigRouteRequestRoutesItem>;
+/** Zero or more child routes. */
+export type UpdateAlertConfigRouteRequestRoutesList = Array<UpdateAlertConfigRouteRequestRoutesItem>;
+export declare const UpdateAlertConfigRouteRequestRoutesList: S.Schema<UpdateAlertConfigRouteRequestRoutesList>;
+export interface UpdateAlertConfigRouteRequest {
+    projectId: string;
+    instanceId: string;
+    receiver: string;
+    /** The continue parameter cannot be set to true on the root route because there are no subsequent sibling nodes to match. It must always be false. */
+    continue?: boolean;
+    /** The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. */
+    groupBy?: UpdateAlertConfigRouteRequestGroupByList;
+    /** How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) `Additional Validators:` * must be a valid time format */
+    groupInterval?: string;
+    /** How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) `Additional Validators:` * must be a valid time format */
+    groupWait?: string;
+    /** map of key:value. A set of equality matchers an alert has to fulfill to match the node. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters * key and values should only include the characters: a-zA-Z0-9_./@&?:- */
+    match?: unknown;
+    /** map of key:value. A set of regex-matchers an alert has to fulfill to match the node. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters */
+    matchRe?: unknown;
+    /** A list of matchers that an alert has to fulfill to match the node. A matcher is a string with a syntax inspired by PromQL and OpenMetrics. The syntax of a matcher consists of three tokens: * A valid Prometheus label name. * One of =, !=, =~, or !~. = means equals, != means that the strings are not equal, =~ is used for equality of regex expressions and !~ is used for un-equality of regex expressions. They have the same meaning as known from PromQL selectors. * A UTF-8 string, which may be enclosed in double quotes. Before or after each token, there may be any amount of whitespace. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters */
+    matchers?: UpdateAlertConfigRouteRequestMatchersList;
+    /** How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). `Additional Validators:` * must be a valid time format */
+    repeatInterval?: string;
+    /** Zero or more child routes. */
+    routes?: UpdateAlertConfigRouteRequestRoutesList;
+}
+export declare const UpdateAlertConfigRouteRequest: S.Schema<UpdateAlertConfigRouteRequest>;
+/** Global config. If nothing passed the default argus config will be used. It is only possible to update the entire global part, not individual attributes. */
+export interface UpdateAlertConfigsRequestGlobal {
+    /** Opsgenie api key `Additional Validators:` * should only include the characters: a-zA-Z0-9- */
+    opsgenieApiKey?: string;
+    /** Opsgenie api url `Additional Validators:` * must be a syntactically valid url address */
+    opsgenieApiUrl?: string;
+    /** ResolveTimeout is the default value used by alertmanager if the alert does not include EndsAt, after this time passes it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. `Additional Validators:` * must be a valid time format */
+    resolveTimeout?: string;
+    /** Auth identity. `Additional Validators:` * must be a syntactically valid email address */
+    smtpAuthIdentity?: string;
+    /** SMTP Auth using LOGIN and PLAIN. */
+    smtpAuthPassword?: string | Redacted.Redacted<string>;
+    /** SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. */
+    smtpAuthUsername?: string;
+    /** The default SMTP From header field. `Additional Validators:` * must be a syntactically valid email address */
+    smtpFrom?: string;
+    /** The default SMTP smarthost used for sending emails, including port number. Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). Example: smtp.example.org:587 `Additional Validators:` * should only include the characters: a-zA-Z0-9_./@&?:- */
+    smtpSmarthost?: string;
+}
+export declare const UpdateAlertConfigsRequestGlobal: S.Schema<UpdateAlertConfigsRequestGlobal>;
+/** Labels that must have an equal value in the source and target alert for the inhibition to take effect. `Additional Validators:` * should only include the characters: a-zA-Z0-9_./@&?:- */
+export type UpdateAlertConfigsRequestInhibitRulesEqualList = Array<string>;
+export declare const UpdateAlertConfigsRequestInhibitRulesEqualList: S.Schema<UpdateAlertConfigsRequestInhibitRulesEqualList>;
+/** A list of inhibition rules. */
+export interface UpdateAlertConfigsRequestInhibitRules {
+    /** Labels that must have an equal value in the source and target alert for the inhibition to take effect. `Additional Validators:` * should only include the characters: a-zA-Z0-9_./@&?:- */
+    equal?: UpdateAlertConfigsRequestInhibitRulesEqualList;
+    /** map of key:value. Matchers for which one or more alerts have to exist for the inhibition to take effect. `Additional Validators:` * should not contain more than 5 keys * each key and value should not have more than 200 characters * each key and value should only include the characters: a-zA-Z0-9_./@&?:- */
+    sourceMatch?: unknown;
+    /** map of key:value. Regex match `Additional Validators:` * should not contain more than 5 keys * each key and value should not have more than 200 characters */
+    sourceMatchRe?: unknown;
+    /** map of key:value. Matchers that have to be fulfilled in the alerts to be muted. `Additional Validators:` * should not contain more than 5 keys * each key and value should not have more than 200 characters * each key and value should only include the characters: a-zA-Z0-9_./@&?:- */
+    targetMatch?: unknown;
+    /** map of key:value. Matchers that have to be fulfilled in the alerts to be muted. Regex. `Additional Validators:` * should not contain more than 5 keys * each key and value should not have more than 200 characters */
+    targetMatchRe?: unknown;
+}
+export declare const UpdateAlertConfigsRequestInhibitRules: S.Schema<UpdateAlertConfigsRequestInhibitRules>;
+export type UpdateAlertConfigsRequestReceiversItemEmailConfigsItem = CreateAlertConfigReceiverRequestEmailConfigsItem;
+export declare const UpdateAlertConfigsRequestReceiversItemEmailConfigsItem: S.Schema<CreateAlertConfigReceiverRequestEmailConfigsItem>;
+/** Email configurations */
+export type UpdateAlertConfigsRequestReceiversItemEmailConfigsList = Array<CreateAlertConfigReceiverRequestEmailConfigsItem>;
+export declare const UpdateAlertConfigsRequestReceiversItemEmailConfigsList: S.Schema<UpdateAlertConfigsRequestReceiversItemEmailConfigsList>;
+export type UpdateAlertConfigsRequestReceiversItemOpsgenieConfigsItem = CreateAlertConfigReceiverRequestOpsgenieConfigsItem;
+export declare const UpdateAlertConfigsRequestReceiversItemOpsgenieConfigsItem: S.Schema<CreateAlertConfigReceiverRequestOpsgenieConfigsItem>;
+/** Configuration for ops genie. */
+export type UpdateAlertConfigsRequestReceiversItemOpsgenieConfigsList = Array<CreateAlertConfigReceiverRequestOpsgenieConfigsItem>;
+export declare const UpdateAlertConfigsRequestReceiversItemOpsgenieConfigsList: S.Schema<UpdateAlertConfigsRequestReceiversItemOpsgenieConfigsList>;
+export type UpdateAlertConfigsRequestReceiversItemWebHookConfigsItem = CreateAlertConfigReceiverRequestWebHookConfigsItem;
+export declare const UpdateAlertConfigsRequestReceiversItemWebHookConfigsItem: S.Schema<CreateAlertConfigReceiverRequestWebHookConfigsItem>;
+export type UpdateAlertConfigsRequestReceiversItemWebHookConfigsList = Array<CreateAlertConfigReceiverRequestWebHookConfigsItem>;
+export declare const UpdateAlertConfigsRequestReceiversItemWebHookConfigsList: S.Schema<UpdateAlertConfigsRequestReceiversItemWebHookConfigsList>;
+/** Receivers */
+export interface UpdateAlertConfigsRequestReceiversItem {
+    /** Email configurations */
+    emailConfigs?: UpdateAlertConfigsRequestReceiversItemEmailConfigsList;
+    /** `Additional Validators:` * must be unique * should only include the characters: a-zA-Z0-9- */
+    name: string;
+    /** Configuration for ops genie. */
+    opsgenieConfigs?: UpdateAlertConfigsRequestReceiversItemOpsgenieConfigsList;
+    webHookConfigs?: UpdateAlertConfigsRequestReceiversItemWebHookConfigsList;
+}
+export declare const UpdateAlertConfigsRequestReceiversItem: S.Schema<UpdateAlertConfigsRequestReceiversItem>;
+/** A list of notification receivers. */
+export type UpdateAlertConfigsRequestReceiversList = Array<UpdateAlertConfigsRequestReceiversItem>;
+export declare const UpdateAlertConfigsRequestReceiversList: S.Schema<UpdateAlertConfigsRequestReceiversList>;
+/** The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. */
+export type UpdateAlertConfigsRequestRouteGroupByList = Array<string>;
+export declare const UpdateAlertConfigsRequestRouteGroupByList: S.Schema<UpdateAlertConfigsRequestRouteGroupByList>;
+export type UpdateAlertConfigsRequestRouteRoutesItemGroupByList = Array<string>;
+export declare const UpdateAlertConfigsRequestRouteRoutesItemGroupByList: S.Schema<UpdateAlertConfigsRequestRouteRoutesItemGroupByList>;
+/** A list of matchers that an alert has to fulfill to match the node. A matcher is a string with a syntax inspired by PromQL and OpenMetrics. The syntax of a matcher consists of three tokens: * A valid Prometheus label name. * One of =, !=, =~, or !~. = means equals, != means that the strings are not equal, =~ is used for equality of regex expressions and !~ is used for un-equality of regex expressions. They have the same meaning as known from PromQL selectors. * A UTF-8 string, which may be enclosed in double quotes. Before or after each token, there may be any amount of whitespace. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters */
+export type UpdateAlertConfigsRequestRouteRoutesItemMatchersList = Array<string>;
+export declare const UpdateAlertConfigsRequestRouteRoutesItemMatchersList: S.Schema<UpdateAlertConfigsRequestRouteRoutesItemMatchersList>;
+/** Another child routes */
+export type UpdateAlertConfigsRequestRouteRoutesItemRoutesList = Array<unknown>;
+export declare const UpdateAlertConfigsRequestRouteRoutesItemRoutesList: S.Schema<UpdateAlertConfigsRequestRouteRoutesItemRoutesList>;
+/** As in one level above */
+export interface UpdateAlertConfigsRequestRouteRoutesItem {
+    /** Whether an alert should continue matching subsequent sibling nodes. */
+    continue?: boolean;
+    groupBy?: UpdateAlertConfigsRequestRouteRoutesItemGroupByList;
+    /** As in one level above */
+    groupInterval?: string;
+    /** As in one level above */
+    groupWait?: string;
+    /** As in one level above */
+    match?: unknown;
+    /** As in one level above */
+    matchRe?: unknown;
+    /** A list of matchers that an alert has to fulfill to match the node. A matcher is a string with a syntax inspired by PromQL and OpenMetrics. The syntax of a matcher consists of three tokens: * A valid Prometheus label name. * One of =, !=, =~, or !~. = means equals, != means that the strings are not equal, =~ is used for equality of regex expressions and !~ is used for un-equality of regex expressions. They have the same meaning as known from PromQL selectors. * A UTF-8 string, which may be enclosed in double quotes. Before or after each token, there may be any amount of whitespace. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters */
+    matchers?: UpdateAlertConfigsRequestRouteRoutesItemMatchersList;
+    /** As in one level above */
+    receiver?: string;
+    /** As in one level above */
+    repeatInterval?: string;
+    /** Another child routes */
+    routes?: UpdateAlertConfigsRequestRouteRoutesItemRoutesList;
+}
+export declare const UpdateAlertConfigsRequestRouteRoutesItem: S.Schema<UpdateAlertConfigsRequestRouteRoutesItem>;
+/** Zero or more child routes. */
+export type UpdateAlertConfigsRequestRouteRoutesList = Array<UpdateAlertConfigsRequestRouteRoutesItem>;
+export declare const UpdateAlertConfigsRequestRouteRoutesList: S.Schema<UpdateAlertConfigsRequestRouteRoutesList>;
+/** The root node of the routing tree. */
+export interface UpdateAlertConfigsRequestRoute {
+    /** The continue parameter cannot be set to true on the root route because there are no subsequent sibling nodes to match. It must always be false. */
+    continue?: boolean;
+    /** The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. */
+    groupBy?: UpdateAlertConfigsRequestRouteGroupByList;
+    /** How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) `Additional Validators:` * must be a valid time format */
+    groupInterval?: string;
+    /** How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) `Additional Validators:` * must be a valid time format */
+    groupWait?: string;
+    /** map of key:value. A set of equality matchers an alert has to fulfill to match the node. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters * key and values should only include the characters: a-zA-Z0-9_./@&?:- */
+    match?: unknown;
+    /** map of key:value. A set of regex-matchers an alert has to fulfill to match the node. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters */
+    matchRe?: unknown;
+    /** Receiver that should be one item of receivers `Additional Validators:` * must be a in name of receivers */
+    receiver: string;
+    /** How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). `Additional Validators:` * must be a valid time format */
+    repeatInterval?: string;
+    /** Zero or more child routes. */
+    routes?: UpdateAlertConfigsRequestRouteRoutesList;
+}
+export declare const UpdateAlertConfigsRequestRoute: S.Schema<UpdateAlertConfigsRequestRoute>;
+export interface UpdateAlertConfigsRequest {
+    projectId: string;
+    instanceId: string;
+    /** Global config. If nothing passed the default argus config will be used. It is only possible to update the entire global part, not individual attributes. */
+    global?: UpdateAlertConfigsRequestGlobal;
+    /** A list of inhibition rules. */
+    inhibitRules?: UpdateAlertConfigsRequestInhibitRules;
+    /** A list of notification receivers. */
+    receivers: UpdateAlertConfigsRequestReceiversList;
+    /** The root node of the routing tree. */
+    route: UpdateAlertConfigsRequestRoute;
+}
+export declare const UpdateAlertConfigsRequest: S.Schema<UpdateAlertConfigsRequest>;
+export interface UpdateAlertConfigsResponse {
+    data: Alert;
+    message: string;
+}
+export declare const UpdateAlertConfigsResponse: S.Schema<UpdateAlertConfigsResponse>;
+/** Rule definition. Must be either an Alerting Rule (using 'alert') or a Recording Rule (using 'record'). `Additional Validators:` * total config (all alert groups/rules) should not be bigger than 500000 characters as string since this the limitation of prometheus. */
+export type UpdateAlertgroupRequestRulesItem = CreateAlertgroupsRequestRulesItem;
+export declare const UpdateAlertgroupRequestRulesItem: S.Schema<CreateAlertgroupsRequestRulesItem>;
+/** rules for the alert group */
+export type UpdateAlertgroupRequestRulesList = Array<CreateAlertgroupsRequestRulesItem>;
+export declare const UpdateAlertgroupRequestRulesList: S.Schema<UpdateAlertgroupRequestRulesList>;
+export interface UpdateAlertgroupRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+    /** How often rules in the group are evaluated. `Additional Validators:` * must be a valid time string * should be >=60s */
+    interval?: string;
+    /** rules for the alert group */
+    rules: UpdateAlertgroupRequestRulesList;
+}
+export declare const UpdateAlertgroupRequest: S.Schema<UpdateAlertgroupRequest>;
+/** Rule definition. Must be either an Alerting Rule (using 'alert') or a Recording Rule (using 'record'). `Additional Validators:` * total config (all alert groups/rules) should not be bigger than 500000 characters as string since this the limitation of prometheus. */
+export type UpdateAlertgroupsRequestBodyItemRulesItem = CreateAlertgroupsRequestRulesItem;
+export declare const UpdateAlertgroupsRequestBodyItemRulesItem: S.Schema<CreateAlertgroupsRequestRulesItem>;
+/** rules for the alert group */
+export type UpdateAlertgroupsRequestBodyItemRulesList = Array<CreateAlertgroupsRequestRulesItem>;
+export declare const UpdateAlertgroupsRequestBodyItemRulesList: S.Schema<UpdateAlertgroupsRequestBodyItemRulesList>;
+/** Alert group that should be created or updated. `Additional Validators:` * total config should not be bigger than 500000 characters as string since this the limitation of prometheus. */
+export interface UpdateAlertgroupsRequestBodyItem {
+    /** How often rules in the group are evaluated. `Additional Validators:` * must be a valid time string * should be >=60s */
+    interval?: string;
+    /** The name of the group. Must be unique. `Additional Validators:` * is the identifier and so unique * should only include the characters: a-zA-Z0-9- */
+    name: string;
+    /** rules for the alert group */
+    rules: UpdateAlertgroupsRequestBodyItemRulesList;
+}
+export declare const UpdateAlertgroupsRequestBodyItem: S.Schema<UpdateAlertgroupsRequestBodyItem>;
+/** Array of alert groups that should be set. It will override all existing alert groups. */
+export type UpdateAlertgroupsRequestBodyList = Array<UpdateAlertgroupsRequestBodyItem>;
+export declare const UpdateAlertgroupsRequestBodyList: S.Schema<UpdateAlertgroupsRequestBodyList>;
+export interface UpdateAlertgroupsRequest {
+    projectId: string;
+    instanceId: string;
+    body: UpdateAlertgroupsRequestBodyList;
+}
+export declare const UpdateAlertgroupsRequest: S.Schema<UpdateAlertgroupsRequest>;
+export interface UpdateAlertRecordRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+    alertRecord: string;
+    /** The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. */
+    expr: string;
+    /** map of key:value. Labels to add or overwrite for each alert. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters */
+    labels?: unknown;
+}
+export declare const UpdateAlertRecordRequest: S.Schema<UpdateAlertRecordRequest>;
+export interface UpdateAlertruleRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+    alertName: string;
+    /** map of key:value. Annotations to add to each alert. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters */
+    annotations?: unknown;
+    /** The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. */
+    expr: string;
+    /** Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. `Additional Validators:` * must be a valid time string */
+    for?: string;
+    /** map of key:value. Labels to add or overwrite for each alert. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters */
+    labels?: unknown;
+}
+export declare const UpdateAlertruleRequest: S.Schema<UpdateAlertruleRequest>;
+export interface UpdateCredentialsRemoteWriteConfigRequest {
+    projectId: string;
+    instanceId: string;
+    username: string;
+    /** Remote write metric sample limit for credential to push in a single minute. */
+    maxLimit?: number;
+}
+export declare const UpdateCredentialsRemoteWriteConfigRequest: S.Schema<UpdateCredentialsRemoteWriteConfigRequest>;
+export interface UpdateGrafanaConfigsRequestGenericOauth {
+    /** Set to true to enable automatic sync of the Grafana server administrator role. If this option is set to true and the result of evaluating role_attribute_path for a user is GrafanaAdmin, Grafana grants the user the server administrator privileges and organization administrator role. If this option is set to false and the result of evaluating role_attribute_path for a user is GrafanaAdmin, Grafana grants the user only organization administrator role. */
+    allowAssignGrafanaAdmin?: boolean;
+    /** Set api_url to the resource that returns OpenID UserInfo compatible information. */
+    apiUrl: string;
+    /** Authentication endpoint of idp. */
+    authUrl: string;
+    /** Enable or disable generic oauth login */
+    enabled: boolean;
+    /** Display name for the oAuth provider */
+    name?: string;
+    /** Oauth client id for auth endpoint. */
+    oauthClientId: string;
+    /** Oauth client secret for auth endpoint. */
+    oauthClientSecret: string;
+    /** Grafana checks for the presence of a role using the JMESPath specified via the role_attribute_path configuration option. The JMESPath is applied to the id_token first. If there is no match, then the UserInfo endpoint specified via the api_url configuration option is tried next. The result after evaluation of the role_attribute_path JMESPath expression should be a valid Grafana role, for example, Viewer, Editor or Admin For example: contains(roles[\*], 'grafana-admin') && 'Admin' || contains(roles[\*], 'grafana-editor') && 'Editor' || contains(roles[\*], 'grafana-viewer') && 'Viewer' */
+    roleAttributePath: string;
+    /** If the role_attribute_path property does not return a role, then the user is assigned the Viewer role by default. You can disable the role assignment by setting role_attribute_strict = true. It denies user access if no role or an invalid role is returned. */
+    roleAttributeStrict?: boolean;
+    /** Space seperated list of scopes of the token */
+    scopes?: string;
+    /** Token endpoint of the idp. */
+    tokenUrl: string;
+    /** Enable or disable Proof Key for Code Exchange */
+    usePkce?: boolean;
+}
+export declare const UpdateGrafanaConfigsRequestGenericOauth: S.Schema<UpdateGrafanaConfigsRequestGenericOauth>;
+export interface UpdateGrafanaConfigsRequest {
+    projectId: string;
+    instanceId: string;
+    genericOauth?: UpdateGrafanaConfigsRequestGenericOauth;
+    /** If it's true, anyone can access the Grafana dashboards without logging in. If it is wrong, a login is required. */
+    publicReadAccess?: boolean;
+    /** If it's true, it overwrites the current genericOauth config and configures STACKIT SSO for this instance. */
+    useStackitSso?: boolean;
+}
+export declare const UpdateGrafanaConfigsRequest: S.Schema<UpdateGrafanaConfigsRequest>;
+export interface UpdateInstanceRequest {
+    projectId: string;
+    instanceId: string;
+    /** When set to false, the Grafana server admin created during provisioning will be deleted. It's recommended to set this to false and use STACKIT SSO (`Owner` or `Observability Grafana Server Admin` role) instead. It is still possible to manually create a new Grafana admin user via the Grafana UI later. Once set to false, it is not possible to set it to true again. */
+    grafanaAdminEnabled?: boolean;
+    /** Name of the service */
+    name?: string;
+    /** Additional parameters */
+    parameter?: unknown;
+    /** UUID of the plan to update */
+    planId?: string;
+}
+export declare const UpdateInstanceRequest: S.Schema<UpdateInstanceRequest>;
+/** Rule definition. Must be either an Alerting Rule (using 'alert') or a Recording Rule (using 'record'). `Additional Validators:` * total config (all alert groups/rules) should not be bigger than 500000 characters as string since this the limitation of prometheus. */
+export type UpdateLogsAlertgroupRequestRulesItem = CreateLogsAlertgroupsRequestRulesItem;
+export declare const UpdateLogsAlertgroupRequestRulesItem: S.Schema<CreateLogsAlertgroupsRequestRulesItem>;
+/** rules for the alert group */
+export type UpdateLogsAlertgroupRequestRulesList = Array<CreateLogsAlertgroupsRequestRulesItem>;
+export declare const UpdateLogsAlertgroupRequestRulesList: S.Schema<UpdateLogsAlertgroupRequestRulesList>;
+export interface UpdateLogsAlertgroupRequest {
+    projectId: string;
+    instanceId: string;
+    groupName: string;
+    /** How often rules in the group are evaluated. `Additional Validators:` * must be a valid time string * should be >=60s */
+    interval?: string;
+    /** rules for the alert group */
+    rules: UpdateLogsAlertgroupRequestRulesList;
+}
+export declare const UpdateLogsAlertgroupRequest: S.Schema<UpdateLogsAlertgroupRequest>;
+export interface UpdateLogsConfigsRequest {
+    projectId: string;
+    instanceId: string;
+    /** How long to keep the logs `Additional Validators:` * Should be a valid time string * Should not be longer than 30 days */
+    retention: string;
+}
+export declare const UpdateLogsConfigsRequest: S.Schema<UpdateLogsConfigsRequest>;
+export interface UpdateMetricsStorageRetentionRequest {
+    projectId: string;
+    instanceId: string;
+    /** Retention time of longtime storage of 1h sampled data. After that time the 1h sampled data will be deleted permanently. The goal of downsampling is to get fast results for queries over long time intervals. It is recommended to set this value to be the same as metricsRetentionTimeRaw to ensure zoom-in capabilities in your dashboards. The default value is 90 days. `Additional Validators:` * Should be a valid time string (e.g. '90d'). * Should be between '10d' and '780d'. * Note: For compatibility reasons, values between '0d' and '792d' are also accepted. However, these will be automatically adjusted in the backend to the recommended range of '10d' to '780d'. */
+    metricsRetentionTime1h: string;
+    /** Retention time of longtime storage of 5m sampled data. After that time the 5m sampled data will be deleted permanently. All 5m resolution metrics older than 10 days are downsampled at a 1h resolution. The goal of downsampling is to get fast results for queries over long time intervals. It is recommended to set this value to be the same as metricsRetentionTimeRaw to ensure zoom-in capabilities in your dashboards. The default value is 90 days. `Additional Validators:` * Should be a valid time string (e.g. '90d'). * Should be between '10d' and '780d'. * Note: For compatibility reasons, values between '0d' and '792d' are also accepted. However, these will be automatically adjusted in the backend to the recommended range of '10d' to '780d'. */
+    metricsRetentionTime5m: string;
+    /** Retention time of longtime storage of raw data. After that time the raw data will be deleted permanently. All raw resolution metrics that are older than 40 hours are downsampled at a 5m resolution. The default value is 90 days. `Additional Validators:` * Should be a valid time string (e.g. '90d'). * Should be between '2d' and '780d'. * Note: For compatibility reasons, values between '0d' and '792d' are also accepted. However, these will be automatically adjusted in the backend to the recommended range of '2d' to '780d'. */
+    metricsRetentionTimeRaw: string;
+}
+export declare const UpdateMetricsStorageRetentionRequest: S.Schema<UpdateMetricsStorageRetentionRequest>;
+/** Sets the 'Authorization' header on every scrape request with the configured username and password. `Additional Validators:` * if basicAuth is in the body no other authentication method should be in the body */
+export type UpdateScrapeConfigRequestBasicAuth = CreateScrapeConfigRequestBasicAuth;
+export declare const UpdateScrapeConfigRequestBasicAuth: S.Schema<CreateScrapeConfigRequestBasicAuth>;
+/** Action to perform based on regex matching. `Additional Validators:` * if action is replace, targetLabel needs to be in body */
+export type UpdateScrapeConfigRequestMetricsRelabelConfigsItemAction = "replace" | "keep" | "drop" | "hashmod" | "labelmap" | "labeldrop" | "labelkeep";
+export declare const UpdateScrapeConfigRequestMetricsRelabelConfigsItemAction: any;
+/** The source labels select values from existing labels. Their content is concatenated using the configured separator and matched against the configured regular expression for the replace, keep, and drop actions. */
+export type UpdateScrapeConfigRequestMetricsRelabelConfigsItemSourceLabelsList = Array<string>;
+export declare const UpdateScrapeConfigRequestMetricsRelabelConfigsItemSourceLabelsList: S.Schema<UpdateScrapeConfigRequestMetricsRelabelConfigsItemSourceLabelsList>;
+export interface UpdateScrapeConfigRequestMetricsRelabelConfigsItem {
+    /** Action to perform based on regex matching. `Additional Validators:` * if action is replace, targetLabel needs to be in body */
+    action?: UpdateScrapeConfigRequestMetricsRelabelConfigsItemAction | (string & {});
+    /** Modulus to take of the hash of the source label values. */
+    modulus?: number;
+    /** Regular expression against which the extracted value is matched. */
+    regex?: string;
+    /** Replacement value against which a regex replace is performed if the regular expression matches. Regex capture groups are available. */
+    replacement?: string;
+    /** Separator placed between concatenated source label values. */
+    separator?: string;
+    /** The source labels select values from existing labels. Their content is concatenated using the configured separator and matched against the configured regular expression for the replace, keep, and drop actions. */
+    sourceLabels?: UpdateScrapeConfigRequestMetricsRelabelConfigsItemSourceLabelsList;
+    /** Label to which the resulting value is written in a replace action. It is mandatory for replace actions. Regex capture groups are available. */
+    targetLabel?: string;
+}
+export declare const UpdateScrapeConfigRequestMetricsRelabelConfigsItem: S.Schema<UpdateScrapeConfigRequestMetricsRelabelConfigsItem>;
+/** List of metric relabel configurations */
+export type UpdateScrapeConfigRequestMetricsRelabelConfigsList = Array<UpdateScrapeConfigRequestMetricsRelabelConfigsItem>;
+export declare const UpdateScrapeConfigRequestMetricsRelabelConfigsList: S.Schema<UpdateScrapeConfigRequestMetricsRelabelConfigsList>;
+/** Configures the protocol scheme used for requests. https or http */
+export type UpdateScrapeConfigRequestScheme = "http" | "https";
+export declare const UpdateScrapeConfigRequestScheme: any;
+/** The targets specified by the static config. */
+export type UpdateScrapeConfigRequestStaticConfigsItemTargetsList = Array<string>;
+export declare const UpdateScrapeConfigRequestStaticConfigsItemTargetsList: S.Schema<UpdateScrapeConfigRequestStaticConfigsItemTargetsList>;
+export interface UpdateScrapeConfigRequestStaticConfigsItem {
+    /** Labels assigned to all metrics scraped from the targets. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters */
+    labels?: unknown;
+    /** The targets specified by the static config. */
+    targets: UpdateScrapeConfigRequestStaticConfigsItemTargetsList;
+}
+export declare const UpdateScrapeConfigRequestStaticConfigsItem: S.Schema<UpdateScrapeConfigRequestStaticConfigsItem>;
+/** A list of scrape configurations. */
+export type UpdateScrapeConfigRequestStaticConfigsList = Array<UpdateScrapeConfigRequestStaticConfigsItem>;
+export declare const UpdateScrapeConfigRequestStaticConfigsList: S.Schema<UpdateScrapeConfigRequestStaticConfigsList>;
+/** Configures the scrape request's TLS settings. */
+export type UpdateScrapeConfigRequestTlsConfig = CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+export declare const UpdateScrapeConfigRequestTlsConfig: S.Schema<CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig>;
+export interface UpdateScrapeConfigRequest {
+    projectId: string;
+    instanceId: string;
+    jobName: string;
+    /** Sets the 'Authorization' header on every scrape request with the configured username and password. `Additional Validators:` * if basicAuth is in the body no other authentication method should be in the body */
+    basicAuth?: CreateScrapeConfigRequestBasicAuth;
+    /** Sets the 'Authorization' header on every scrape request with the configured bearer token. It is mutually exclusive with 'bearer_token_file'. `Additional Validators:` * needs to be a valid bearer token * if bearerToken is in the body no other authentication method should be in the body */
+    bearerToken?: string;
+    /** Note that any globally configured 'external_labels' are unaffected by this setting. In communication with external systems, they are always applied only when a time series does not have a given label yet and are ignored otherwise. */
+    honorLabels?: boolean;
+    /** honor_timestamps controls whether Prometheus respects the timestamps present in scraped data. If honor_timestamps is set to 'true', the timestamps of the metrics exposed by the target will be used. */
+    honorTimeStamps?: boolean;
+    /** The HTTP resource path on which to fetch metrics from targets. E.g. /metrics */
+    metricsPath: string;
+    /** List of metric relabel configurations */
+    metricsRelabelConfigs?: UpdateScrapeConfigRequestMetricsRelabelConfigsList;
+    /** Optional http params `Additional Validators:` * should not contain more than 5 keys * each key and value should not have more than 200 characters */
+    params?: unknown;
+    /** Per-scrape limit on number of scraped samples that will be accepted. If more than this number of samples are present after metric relabeling the entire scrape will be treated as failed. The total limit depends on the service plan target limits * samples */
+    sampleLimit?: number;
+    /** Configures the protocol scheme used for requests. https or http */
+    scheme: UpdateScrapeConfigRequestScheme | (string & {});
+    /** How frequently to scrape targets from this job. E.g. 5m `Additional Validators:` * must be a valid time format* must be >= 60s */
+    scrapeInterval: string;
+    /** Per-scrape timeout when scraping this job. `Additional Validators:` * must be a valid time format* must be smaller than scrapeInterval */
+    scrapeTimeout: string;
+    /** A list of scrape configurations. */
+    staticConfigs: UpdateScrapeConfigRequestStaticConfigsList;
+    /** Configures the scrape request's TLS settings. */
+    tlsConfig?: CreateScrapeConfigRequestHttpSdConfigsItemOauth2TlsConfig;
+}
+export declare const UpdateScrapeConfigRequest: S.Schema<UpdateScrapeConfigRequest>;
+export interface UpdateTracesConfigsRequest {
+    projectId: string;
+    instanceId: string;
+    /** How long to keep the traces `Additional Validators:` * Should be a valid time string * Should not be bigger than 30 days */
+    retention: string;
+}
+export declare const UpdateTracesConfigsRequest: S.Schema<UpdateTracesConfigsRequest>;
+export type CreateAlertConfigReceiverError = BadRequest | Forbidden | StackitOpError;
+/** Create alert config receiver. */
+export declare const createAlertConfigReceiver: API.OperationMethod<CreateAlertConfigReceiverRequest, AlertConfigReceiversResponse, CreateAlertConfigReceiverError, StackitOpContext>;
+export type CreateAlertConfigRouteError = BadRequest | Forbidden | StackitOpError;
+/** Create alert config route in routes of route. */
+export declare const createAlertConfigRoute: API.OperationMethod<CreateAlertConfigRouteRequest, AlertConfigRouteResponse, CreateAlertConfigRouteError, StackitOpContext>;
+export type CreateAlertgroupsError = BadRequest | Forbidden | StackitOpError;
+/** Create alert group. */
+export declare const createAlertgroups: API.OperationMethod<CreateAlertgroupsRequest, AlertGroupsResponse, CreateAlertgroupsError, StackitOpContext>;
+export type CreateAlertRecordError = BadRequest | Forbidden | StackitOpError;
+/** Create alert record. */
+export declare const createAlertRecord: API.OperationMethod<CreateAlertRecordRequest, AlertRecordsResponse, CreateAlertRecordError, StackitOpContext>;
+export type CreateAlertrulesError = BadRequest | Forbidden | StackitOpError;
+/** Create alert rule. */
+export declare const createAlertrules: API.OperationMethod<CreateAlertrulesRequest, AlertRulesResponse, CreateAlertrulesError, StackitOpContext>;
+export type CreateBackupError = BadRequest | Forbidden | StackitOpError;
+/** Create a backup. */
+export declare const createBackup: API.OperationMethod<CreateBackupRequest, Message, CreateBackupError, StackitOpContext>;
+export type CreateBackupScheduleError = BadRequest | Forbidden | StackitOpError;
+/** Create backup schedule. */
+export declare const createBackupSchedule: API.OperationMethod<CreateBackupScheduleRequest, BackupSchedulePostResponse, CreateBackupScheduleError, StackitOpContext>;
+export type CreateCertCheckError = BadRequest | Forbidden | StackitOpError;
+/** Create cert check. */
+export declare const createCertCheck: API.OperationMethod<CreateCertCheckRequest, CertCheckResponse, CreateCertCheckError, StackitOpContext>;
+export type CreateCredentialsError = BadRequest | Forbidden | StackitOpError;
+/** Create technical user credentials. */
+export declare const createCredentials: API.OperationMethod<CreateCredentialsRequest, CreateCredentialsResponse, CreateCredentialsError, StackitOpContext>;
+export type CreateElasticsearchCheckError = BadRequest | Forbidden | StackitOpError;
+/** Create elasticsearch check. */
+export declare const createElasticsearchCheck: API.OperationMethod<CreateElasticsearchCheckRequest, ElasticsearchCheckResponse, CreateElasticsearchCheckError, StackitOpContext>;
+export type CreateHttpCheckError = BadRequest | Forbidden | StackitOpError;
+/** Create http check. */
+export declare const createHttpCheck: API.OperationMethod<CreateHttpCheckRequest, HttpCheckResponse, CreateHttpCheckError, StackitOpContext>;
+export type CreateInstanceError = BadRequest | Forbidden | StackitOpError;
+/** Create new instance. */
+export declare const createInstance: API.OperationMethod<CreateInstanceRequest, CreateInstanceResponse, CreateInstanceError, StackitOpContext>;
+export type CreateLogsAlertgroupsError = BadRequest | Forbidden | StackitOpError;
+/** Create logs alert group config. */
+export declare const createLogsAlertgroups: API.OperationMethod<CreateLogsAlertgroupsRequest, AlertGroupsResponse, CreateLogsAlertgroupsError, StackitOpContext>;
+export type CreateMongodbCheckError = BadRequest | Forbidden | StackitOpError;
+/** Create mongodb check. */
+export declare const createMongodbCheck: API.OperationMethod<CreateMongodbCheckRequest, MongodbCheckResponse, CreateMongodbCheckError, StackitOpContext>;
+export type CreateMysqlCheckError = BadRequest | Forbidden | StackitOpError;
+/** Create mysql check. */
+export declare const createMysqlCheck: API.OperationMethod<CreateMysqlCheckRequest, MysqlCheckResponse, CreateMysqlCheckError, StackitOpContext>;
+export type CreateNetworkCheckError = BadRequest | Forbidden | StackitOpError;
+/** Create network check. */
+export declare const createNetworkCheck: API.OperationMethod<CreateNetworkCheckRequest, NetworkCheckResponse, CreateNetworkCheckError, StackitOpContext>;
+export type CreatePingCheckError = BadRequest | Forbidden | StackitOpError;
+/** Create ping check. */
+export declare const createPingCheck: API.OperationMethod<CreatePingCheckRequest, PingCheckResponse, CreatePingCheckError, StackitOpContext>;
+export type CreatePostgresqlCheckError = BadRequest | Forbidden | StackitOpError;
+/** Create postgresql check. */
+export declare const createPostgresqlCheck: API.OperationMethod<CreatePostgresqlCheckRequest, PostgresqlCheckResponse, CreatePostgresqlCheckError, StackitOpContext>;
+export type CreateRabbitmqCheckError = BadRequest | Forbidden | StackitOpError;
+/** Create rabbitmq check. */
+export declare const createRabbitmqCheck: API.OperationMethod<CreateRabbitmqCheckRequest, RabbitmqCheckResponse, CreateRabbitmqCheckError, StackitOpContext>;
+export type CreateRedisCheckError = BadRequest | Forbidden | StackitOpError;
+/** Create redis check. */
+export declare const createRedisCheck: API.OperationMethod<CreateRedisCheckRequest, RedisCheckResponse, CreateRedisCheckError, StackitOpContext>;
+export type CreateScrapeConfigError = BadRequest | Forbidden | StackitOpError;
+/** Create scrape config. */
+export declare const createScrapeConfig: API.OperationMethod<CreateScrapeConfigRequest, ScrapeConfigsResponse, CreateScrapeConfigError, StackitOpContext>;
+export type DeleteAlertConfigReceiverError = Forbidden | NotFound | StackitOpError;
+/** Delete alert config receiver. */
+export declare const deleteAlertConfigReceiver: API.OperationMethod<DeleteAlertConfigReceiverRequest, AlertConfigReceiversResponse, DeleteAlertConfigReceiverError, StackitOpContext>;
+export type DeleteAlertConfigRouteError = Forbidden | NotFound | StackitOpError;
+/** Delete alert receiver for route. */
+export declare const deleteAlertConfigRoute: API.OperationMethod<DeleteAlertConfigRouteRequest, AlertConfigRouteResponse, DeleteAlertConfigRouteError, StackitOpContext>;
+export type DeleteAlertgroupError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Delete alert group config. */
+export declare const deleteAlertgroup: API.OperationMethod<DeleteAlertgroupRequest, AlertGroupsResponse, DeleteAlertgroupError, StackitOpContext>;
+export type DeleteAlertgroupsError = Forbidden | StackitOpError;
+/** Delete alert groups. */
+export declare const deleteAlertgroups: API.OperationMethod<DeleteAlertgroupsRequest, AlertGroupsResponse, DeleteAlertgroupsError, StackitOpContext>;
+export type DeleteAlertRecordError = Forbidden | NotFound | StackitOpError;
+/** Delete alert record. */
+export declare const deleteAlertRecord: API.OperationMethod<DeleteAlertRecordRequest, AlertRecordsResponse, DeleteAlertRecordError, StackitOpContext>;
+export type DeleteAlertRecordsError = Forbidden | StackitOpError;
+/** Delete alert records. */
+export declare const deleteAlertRecords: API.OperationMethod<DeleteAlertRecordsRequest, AlertRecordsResponse, DeleteAlertRecordsError, StackitOpContext>;
+export type DeleteAlertruleError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Delete alert rule. */
+export declare const deleteAlertrule: API.OperationMethod<DeleteAlertruleRequest, AlertRulesResponse, DeleteAlertruleError, StackitOpContext>;
+export type DeleteAlertrulesError = Forbidden | StackitOpError;
+/** Delete alert rules. */
+export declare const deleteAlertrules: API.OperationMethod<DeleteAlertrulesRequest, AlertRulesResponse, DeleteAlertrulesError, StackitOpContext>;
+export type DeleteCertCheckError = BadRequest | Forbidden | StackitOpError;
+/** Delete cert check. */
+export declare const deleteCertCheck: API.OperationMethod<DeleteCertCheckRequest, CertCheckResponse, DeleteCertCheckError, StackitOpContext>;
+export type DeleteCredentialsError = Forbidden | NotFound | StackitOpError;
+/** Delete technical credentials. */
+export declare const deleteCredentials: API.OperationMethod<DeleteCredentialsRequest, Message, DeleteCredentialsError, StackitOpContext>;
+export type DeleteCredentialsRemoteWriteConfigError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Delete remote write config for credentials. */
+export declare const deleteCredentialsRemoteWriteConfig: API.OperationMethod<DeleteCredentialsRemoteWriteConfigRequest, CredentialsRemoteWriteDeleteResponse, DeleteCredentialsRemoteWriteConfigError, StackitOpContext>;
+export type DeleteElasticsearchCheckError = BadRequest | Forbidden | StackitOpError;
+/** Delete elasticsearch check. */
+export declare const deleteElasticsearchCheck: API.OperationMethod<DeleteElasticsearchCheckRequest, ElasticsearchCheckResponse, DeleteElasticsearchCheckError, StackitOpContext>;
+export type DeleteHttpCheckError = BadRequest | Forbidden | StackitOpError;
+/** Delete http check. */
+export declare const deleteHttpCheck: API.OperationMethod<DeleteHttpCheckRequest, HttpCheckResponse, DeleteHttpCheckError, StackitOpContext>;
+export type DeleteInstanceError = Forbidden | StackitOpError;
+/** Delete instance. */
+export declare const deleteInstance: API.OperationMethod<DeleteInstanceRequest, InstanceResponse, DeleteInstanceError, StackitOpContext>;
+export type DeleteLogsAlertgroupError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Delete logs alert group config. */
+export declare const deleteLogsAlertgroup: API.OperationMethod<DeleteLogsAlertgroupRequest, AlertGroupsResponse, DeleteLogsAlertgroupError, StackitOpContext>;
+export type DeleteMongodbCheckError = BadRequest | Forbidden | StackitOpError;
+/** Delete mongodb check. */
+export declare const deleteMongodbCheck: API.OperationMethod<DeleteMongodbCheckRequest, MongodbCheckResponse, DeleteMongodbCheckError, StackitOpContext>;
+export type DeleteMysqlCheckError = BadRequest | Forbidden | StackitOpError;
+/** Delete mysql check. */
+export declare const deleteMysqlCheck: API.OperationMethod<DeleteMysqlCheckRequest, MysqlCheckResponse, DeleteMysqlCheckError, StackitOpContext>;
+export type DeleteNetworkCheckError = BadRequest | Forbidden | StackitOpError;
+/** Delete network check. */
+export declare const deleteNetworkCheck: API.OperationMethod<DeleteNetworkCheckRequest, NetworkCheckResponse, DeleteNetworkCheckError, StackitOpContext>;
+export type DeletePingCheckError = BadRequest | Forbidden | StackitOpError;
+/** Delete ping check. */
+export declare const deletePingCheck: API.OperationMethod<DeletePingCheckRequest, PingCheckResponse, DeletePingCheckError, StackitOpContext>;
+export type DeletePostgresqlCheckError = BadRequest | Forbidden | StackitOpError;
+/** Delete postgresql check. */
+export declare const deletePostgresqlCheck: API.OperationMethod<DeletePostgresqlCheckRequest, PostgresqlCheckResponse, DeletePostgresqlCheckError, StackitOpContext>;
+export type DeleteRabbitmqCheckError = BadRequest | Forbidden | StackitOpError;
+/** Delete rabbitmq check. */
+export declare const deleteRabbitmqCheck: API.OperationMethod<DeleteRabbitmqCheckRequest, RabbitmqCheckResponse, DeleteRabbitmqCheckError, StackitOpContext>;
+export type DeleteRedisCheckError = BadRequest | Forbidden | StackitOpError;
+/** Delete redis check. */
+export declare const deleteRedisCheck: API.OperationMethod<DeleteRedisCheckRequest, RedisCheckResponse, DeleteRedisCheckError, StackitOpContext>;
+export type DeleteScrapeConfigError = Forbidden | NotFound | StackitOpError;
+/** Delete scrape config. */
+export declare const deleteScrapeConfig: API.OperationMethod<DeleteScrapeConfigRequest, DeleteScrapeConfigResponse, DeleteScrapeConfigError, StackitOpContext>;
+export type DeleteScrapeConfigsError = Forbidden | StackitOpError;
+/** Delete scrape configs. */
+export declare const deleteScrapeConfigs: API.OperationMethod<DeleteScrapeConfigsRequest, ScrapeConfigsResponse, DeleteScrapeConfigsError, StackitOpContext>;
+export type GetAlertConfigReceiverError = Forbidden | NotFound | StackitOpError;
+/** Get alert config receivers. */
+export declare const getAlertConfigReceiver: API.OperationMethod<GetAlertConfigReceiverRequest, Receiver, GetAlertConfigReceiverError, StackitOpContext>;
+export type GetAlertConfigRouteError = Forbidden | StackitOpError;
+/** Get alert receiver for route. */
+export declare const getAlertConfigRoute: API.OperationMethod<GetAlertConfigRouteRequest, AlertConfigRouteResponse, GetAlertConfigRouteError, StackitOpContext>;
+export type GetAlertConfigsError = Forbidden | StackitOpError;
+/** Get alert config. */
+export declare const getAlertConfigs: API.OperationMethod<GetAlertConfigsRequest, GetAlertConfigsResponse, GetAlertConfigsError, StackitOpContext>;
+export type GetAlertgroupError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get alert group. */
+export declare const getAlertgroup: API.OperationMethod<GetAlertgroupRequest, AlertGroupResponse, GetAlertgroupError, StackitOpContext>;
+export type GetAlertRecordError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get alert record. */
+export declare const getAlertRecord: API.OperationMethod<GetAlertRecordRequest, AlertRecordResponse, GetAlertRecordError, StackitOpContext>;
+export type GetAlertruleError = Forbidden | NotFound | StackitOpError;
+/** Get alert rule. */
+export declare const getAlertrule: API.OperationMethod<GetAlertruleRequest, AlertRuleResponse, GetAlertruleError, StackitOpContext>;
+export type GetCredentialsError = Forbidden | NotFound | StackitOpError;
+/** Get single technical credentials. */
+export declare const getCredentials: API.OperationMethod<GetCredentialsRequest, GetCredentialsResponse, GetCredentialsError, StackitOpContext>;
+export type GetCredentialsRemoteWriteConfigError = Forbidden | NotFound | StackitOpError;
+/** Get remote write config. */
+export declare const getCredentialsRemoteWriteConfig: API.OperationMethod<GetCredentialsRemoteWriteConfigRequest, CredentialsRemoteWriteConfig, GetCredentialsRemoteWriteConfigError, StackitOpContext>;
+export type GetGrafanaConfigsError = Forbidden | StackitOpError;
+/** Get grafana config. */
+export declare const getGrafanaConfigs: API.OperationMethod<GetGrafanaConfigsRequest, GrafanaConfigs, GetGrafanaConfigsError, StackitOpContext>;
+export type GetInstanceError = Forbidden | StackitOpError;
+/** Get instance information. */
+export declare const getInstance: API.OperationMethod<GetInstanceRequest, GetInstanceResponse, GetInstanceError, StackitOpContext>;
+export type GetLogsAlertgroupError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Get logs alert group config. */
+export declare const getLogsAlertgroup: API.OperationMethod<GetLogsAlertgroupRequest, AlertGroupResponse, GetLogsAlertgroupError, StackitOpContext>;
+export type GetLogsConfigsError = Forbidden | StackitOpError;
+/** Get logs configuration. */
+export declare const getLogsConfigs: API.OperationMethod<GetLogsConfigsRequest, LogsConfigResponse, GetLogsConfigsError, StackitOpContext>;
+export type GetMetricsStorageRetentionError = Forbidden | StackitOpError;
+/** Get metric storage retention time. */
+export declare const getMetricsStorageRetention: API.OperationMethod<GetMetricsStorageRetentionRequest, GetMetricsStorageRetentionResponse, GetMetricsStorageRetentionError, StackitOpContext>;
+export type GetScrapeConfigError = Forbidden | StackitOpError;
+/** Get scrape config. */
+export declare const getScrapeConfig: API.OperationMethod<GetScrapeConfigRequest, GetScrapeConfigResponse, GetScrapeConfigError, StackitOpContext>;
+export type GetTracesConfigsError = Forbidden | StackitOpError;
+/** Get traces config. */
+export declare const getTracesConfigs: API.OperationMethod<GetTracesConfigsRequest, TracesConfigResponse, GetTracesConfigsError, StackitOpContext>;
+export type ListACLError = Forbidden | StackitOpError;
+/** Get acl for instance. */
+export declare const listACL: API.OperationMethod<ListACLRequest, ListACLResponse, ListACLError, StackitOpContext>;
+export type ListAlertConfigReceiversError = Forbidden | StackitOpError;
+/** Get alert config receivers. */
+export declare const listAlertConfigReceivers: API.OperationMethod<ListAlertConfigReceiversRequest, AlertConfigReceiversResponse, ListAlertConfigReceiversError, StackitOpContext>;
+export type ListAlertConfigRoutesError = Forbidden | StackitOpError;
+/** Get alert config route. */
+export declare const listAlertConfigRoutes: API.OperationMethod<ListAlertConfigRoutesRequest, AlertConfigRouteResponse, ListAlertConfigRoutesError, StackitOpContext>;
+export type ListAlertgroupsError = BadRequest | Forbidden | StackitOpError;
+/** Get alert groups. */
+export declare const listAlertgroups: API.OperationMethod<ListAlertgroupsRequest, AlertGroupsResponse, ListAlertgroupsError, StackitOpContext>;
+export type ListAlertRecordsError = Forbidden | StackitOpError;
+/** Get alert records. */
+export declare const listAlertRecords: API.OperationMethod<ListAlertRecordsRequest, AlertRecordsResponse, ListAlertRecordsError, StackitOpContext>;
+export type ListAlertrulesError = Forbidden | StackitOpError;
+/** Get alert rules. */
+export declare const listAlertrules: API.OperationMethod<ListAlertrulesRequest, AlertRulesResponse, ListAlertrulesError, StackitOpContext>;
+export type ListBackupRetentionsError = Forbidden | StackitOpError;
+/** Get backup retention. */
+export declare const listBackupRetentions: API.OperationMethod<ListBackupRetentionsRequest, BackupRetentionResponse, ListBackupRetentionsError, StackitOpContext>;
+export type ListBackupsError = Forbidden | StackitOpError;
+/** Get backups. */
+export declare const listBackups: API.OperationMethod<ListBackupsRequest, BackupResponse, ListBackupsError, StackitOpContext>;
+export type ListBackupSchedulesError = Forbidden | StackitOpError;
+/** Get backup schedules. */
+export declare const listBackupSchedules: API.OperationMethod<ListBackupSchedulesRequest, BackupScheduleResponse, ListBackupSchedulesError, StackitOpContext>;
+export type ListCertChecksError = BadRequest | Forbidden | StackitOpError;
+/** Get all cert checks configured. */
+export declare const listCertChecks: API.OperationMethod<ListCertChecksRequest, CertCheckResponse, ListCertChecksError, StackitOpContext>;
+export type ListCredentialsError = Forbidden | StackitOpError;
+/** Get all technical user credentials. */
+export declare const listCredentials: API.OperationMethod<ListCredentialsRequest, ListCredentialsResponse, ListCredentialsError, StackitOpContext>;
+export type ListElasticsearchChecksError = BadRequest | Forbidden | StackitOpError;
+/** Get all elasticsearch checks configured. */
+export declare const listElasticsearchChecks: API.OperationMethod<ListElasticsearchChecksRequest, ElasticsearchCheckResponse, ListElasticsearchChecksError, StackitOpContext>;
+export type ListHttpChecksError = BadRequest | Forbidden | StackitOpError;
+/** Get all http checks configured. */
+export declare const listHttpChecks: API.OperationMethod<ListHttpChecksRequest, HttpCheckResponse, ListHttpChecksError, StackitOpContext>;
+export type ListInstancesError = Forbidden | StackitOpError;
+/** Get all instances for a project. */
+export declare const listInstances: API.OperationMethod<ListInstancesRequest, ListInstancesResponse, ListInstancesError, StackitOpContext>;
+export type ListLogsAlertgroupsError = BadRequest | Forbidden | StackitOpError;
+/** Get logs alert groups config. */
+export declare const listLogsAlertgroups: API.OperationMethod<ListLogsAlertgroupsRequest, AlertGroupsResponse, ListLogsAlertgroupsError, StackitOpContext>;
+export type ListMongodbChecksError = BadRequest | Forbidden | StackitOpError;
+/** Get all mongodb checks configured. */
+export declare const listMongodbChecks: API.OperationMethod<ListMongodbChecksRequest, MongodbCheckResponse, ListMongodbChecksError, StackitOpContext>;
+export type ListMysqlChecksError = BadRequest | Forbidden | StackitOpError;
+/** Get all mysql checks configured. */
+export declare const listMysqlChecks: API.OperationMethod<ListMysqlChecksRequest, MysqlCheckResponse, ListMysqlChecksError, StackitOpContext>;
+export type ListNetworkChecksError = BadRequest | Forbidden | StackitOpError;
+/** Get all network checks configured. */
+export declare const listNetworkChecks: API.OperationMethod<ListNetworkChecksRequest, NetworkCheckResponse, ListNetworkChecksError, StackitOpContext>;
+export type ListOfferingsError = Forbidden | StackitOpError;
+/** Get all plans. */
+export declare const listOfferings: API.OperationMethod<ListOfferingsRequest, Offerings, ListOfferingsError, StackitOpContext>;
+export type ListPingChecksError = BadRequest | Forbidden | StackitOpError;
+/** Get all ping checks configured. */
+export declare const listPingChecks: API.OperationMethod<ListPingChecksRequest, PingCheckResponse, ListPingChecksError, StackitOpContext>;
+export type ListPlansError = Forbidden | StackitOpError;
+/** Get all plans. */
+export declare const listPlans: API.OperationMethod<ListPlansRequest, PlansResponse, ListPlansError, StackitOpContext>;
+export type ListPostgresqlChecksError = BadRequest | Forbidden | StackitOpError;
+/** Get all postgresql checks configured. */
+export declare const listPostgresqlChecks: API.OperationMethod<ListPostgresqlChecksRequest, PostgresqlCheckResponse, ListPostgresqlChecksError, StackitOpContext>;
+export type ListRabbitmqChecksError = BadRequest | Forbidden | StackitOpError;
+/** Get all rabbitmq checks configured. */
+export declare const listRabbitmqChecks: API.OperationMethod<ListRabbitmqChecksRequest, RabbitmqCheckResponse, ListRabbitmqChecksError, StackitOpContext>;
+export type ListRedisChecksError = BadRequest | Forbidden | StackitOpError;
+/** Get all redis checks configured. */
+export declare const listRedisChecks: API.OperationMethod<ListRedisChecksRequest, RedisCheckResponse, ListRedisChecksError, StackitOpContext>;
+export type ListScrapeConfigsError = Forbidden | StackitOpError;
+/** Get scrape configs. */
+export declare const listScrapeConfigs: API.OperationMethod<ListScrapeConfigsRequest, ListScrapeConfigsResponse, ListScrapeConfigsError, StackitOpContext>;
+export type PartialUpdateAlertgroupsError = BadRequest | Forbidden | StackitOpError;
+/** Patch alert groups. */
+export declare const partialUpdateAlertgroups: API.OperationMethod<PartialUpdateAlertgroupsRequest, AlertGroupsResponse, PartialUpdateAlertgroupsError, StackitOpContext>;
+export type PartialUpdateAlertRecordsError = BadRequest | Forbidden | StackitOpError;
+/** Patch alert records. */
+export declare const partialUpdateAlertRecords: API.OperationMethod<PartialUpdateAlertRecordsRequest, AlertRecordsResponse, PartialUpdateAlertRecordsError, StackitOpContext>;
+export type PartialUpdateAlertrulesError = BadRequest | Forbidden | StackitOpError;
+/** Patch alert rules. */
+export declare const partialUpdateAlertrules: API.OperationMethod<PartialUpdateAlertrulesRequest, AlertRulesResponse, PartialUpdateAlertrulesError, StackitOpContext>;
+export type PartialUpdateScrapeConfigsError = BadRequest | Forbidden | StackitOpError;
+/** Update scrape configs. */
+export declare const partialUpdateScrapeConfigs: API.OperationMethod<PartialUpdateScrapeConfigsRequest, ScrapeConfigsResponse, PartialUpdateScrapeConfigsError, StackitOpContext>;
+export type RestoreBackupError = Forbidden | NotFound | StackitOpError;
+/** Restore backup. */
+export declare const restoreBackup: API.OperationMethod<RestoreBackupRequest, Message, RestoreBackupError, StackitOpContext>;
+export type UpdateACLError = BadRequest | Forbidden | StackitOpError;
+/** Update acl config. */
+export declare const updateACL: API.OperationMethod<UpdateACLRequest, Message, UpdateACLError, StackitOpContext>;
+export type UpdateAlertConfigReceiverError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Update alert config receiver. */
+export declare const updateAlertConfigReceiver: API.OperationMethod<UpdateAlertConfigReceiverRequest, AlertConfigReceiversResponse, UpdateAlertConfigReceiverError, StackitOpContext>;
+export type UpdateAlertConfigRouteError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Update alert receiver for route. */
+export declare const updateAlertConfigRoute: API.OperationMethod<UpdateAlertConfigRouteRequest, AlertConfigRouteResponse, UpdateAlertConfigRouteError, StackitOpContext>;
+export type UpdateAlertConfigsError = BadRequest | Forbidden | StackitOpError;
+/** Update alert config. */
+export declare const updateAlertConfigs: API.OperationMethod<UpdateAlertConfigsRequest, UpdateAlertConfigsResponse, UpdateAlertConfigsError, StackitOpContext>;
+export type UpdateAlertgroupError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Update alert group config. */
+export declare const updateAlertgroup: API.OperationMethod<UpdateAlertgroupRequest, AlertGroupsResponse, UpdateAlertgroupError, StackitOpContext>;
+export type UpdateAlertgroupsError = BadRequest | Forbidden | StackitOpError;
+/** Update alert groups. */
+export declare const updateAlertgroups: API.OperationMethod<UpdateAlertgroupsRequest, AlertGroupsResponse, UpdateAlertgroupsError, StackitOpContext>;
+export type UpdateAlertRecordError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Update alert record. */
+export declare const updateAlertRecord: API.OperationMethod<UpdateAlertRecordRequest, AlertRecordsResponse, UpdateAlertRecordError, StackitOpContext>;
+export type UpdateAlertruleError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Update alert rule. */
+export declare const updateAlertrule: API.OperationMethod<UpdateAlertruleRequest, AlertRulesResponse, UpdateAlertruleError, StackitOpContext>;
+export type UpdateCredentialsRemoteWriteConfigError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Update remote write config for credentials. */
+export declare const updateCredentialsRemoteWriteConfig: API.OperationMethod<UpdateCredentialsRemoteWriteConfigRequest, CredentialsRemoteWriteConfig, UpdateCredentialsRemoteWriteConfigError, StackitOpContext>;
+export type UpdateGrafanaConfigsError = BadRequest | Forbidden | StackitOpError;
+/** Update grafana config. */
+export declare const updateGrafanaConfigs: API.OperationMethod<UpdateGrafanaConfigsRequest, Message, UpdateGrafanaConfigsError, StackitOpContext>;
+export type UpdateInstanceError = BadRequest | Forbidden | StackitOpError;
+/** Update instance. */
+export declare const updateInstance: API.OperationMethod<UpdateInstanceRequest, InstanceResponse, UpdateInstanceError, StackitOpContext>;
+export type UpdateLogsAlertgroupError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Update logs alert group config. */
+export declare const updateLogsAlertgroup: API.OperationMethod<UpdateLogsAlertgroupRequest, AlertGroupsResponse, UpdateLogsAlertgroupError, StackitOpContext>;
+export type UpdateLogsConfigsError = BadRequest | Forbidden | StackitOpError;
+/** Update logs config. */
+export declare const updateLogsConfigs: API.OperationMethod<UpdateLogsConfigsRequest, Message, UpdateLogsConfigsError, StackitOpContext>;
+export type UpdateMetricsStorageRetentionError = BadRequest | Forbidden | StackitOpError;
+/** Update metric update retention time. */
+export declare const updateMetricsStorageRetention: API.OperationMethod<UpdateMetricsStorageRetentionRequest, Message, UpdateMetricsStorageRetentionError, StackitOpContext>;
+export type UpdateScrapeConfigError = BadRequest | Forbidden | NotFound | StackitOpError;
+/** Update scrape config. */
+export declare const updateScrapeConfig: API.OperationMethod<UpdateScrapeConfigRequest, ScrapeConfigsResponse, UpdateScrapeConfigError, StackitOpContext>;
+export type UpdateTracesConfigsError = BadRequest | Forbidden | StackitOpError;
+/** Update traces config. */
+export declare const updateTracesConfigs: API.OperationMethod<UpdateTracesConfigsRequest, Message, UpdateTracesConfigsError, StackitOpContext>;
+//# sourceMappingURL=observability.d.ts.map