import type { AxiosInstance, AxiosPromise, RawAxiosRequestConfig } from "axios";
import type { RequestArgs } from "./base.js";
import { BaseAPI } from "./base.js";
import type { Configuration } from "./configuration.js";
export interface Account {
    droplet_limit: number;
    floating_ip_limit: number;
    email: string;
    name?: string;
    uuid: string;
    email_verified: boolean;
    status: AccountStatusEnum;
    status_message: string;
    team?: AccountTeam;
}
export declare const AccountStatusEnum: {
    readonly Active: "active";
    readonly Warning: "warning";
    readonly Locked: "locked";
};
export type AccountStatusEnum = (typeof AccountStatusEnum)[keyof typeof AccountStatusEnum];
export interface AccountGet200Response {
    account?: Account;
}
export interface AccountTeam {
    uuid?: string;
    name?: string;
}
export interface Action {
    id?: number;
    status?: ActionStatusEnum;
    type?: string;
    started_at?: string;
    completed_at?: string | null;
    resource_id?: number | null;
    resource_type?: string;
    region?: Region;
    region_slug?: string;
}
export declare const ActionStatusEnum: {
    readonly InProgress: "in-progress";
    readonly Completed: "completed";
    readonly Errored: "errored";
};
export type ActionStatusEnum = (typeof ActionStatusEnum)[keyof typeof ActionStatusEnum];
export interface ActionLink {
    id?: number;
    rel?: string;
    href?: string;
}
export interface ActionsGet200Response {
    action?: Action;
}
export interface ActionsList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    actions?: Array<Action>;
}
export interface Alert {
    id?: string;
    name?: string;
    type?: AlertTypeEnum;
    threshold?: number;
    comparison?: AlertComparisonEnum;
    notifications?: Notification;
    period?: AlertPeriodEnum;
}
export declare const AlertTypeEnum: {
    readonly Latency: "latency";
    readonly Down: "down";
    readonly DownGlobal: "down_global";
    readonly SslExpiry: "ssl_expiry";
};
export type AlertTypeEnum = (typeof AlertTypeEnum)[keyof typeof AlertTypeEnum];
export declare const AlertComparisonEnum: {
    readonly GreaterThan: "greater_than";
    readonly LessThan: "less_than";
};
export type AlertComparisonEnum = (typeof AlertComparisonEnum)[keyof typeof AlertComparisonEnum];
export declare const AlertPeriodEnum: {
    readonly _2m: "2m";
    readonly _3m: "3m";
    readonly _5m: "5m";
    readonly _10m: "10m";
    readonly _15m: "15m";
    readonly _30m: "30m";
    readonly _1h: "1h";
};
export type AlertPeriodEnum = (typeof AlertPeriodEnum)[keyof typeof AlertPeriodEnum];
export interface AlertBase {
    id?: string;
}
export interface AlertPolicy {
    alerts: Alerts;
    compare: AlertPolicyCompareEnum;
    description: string;
    enabled: boolean;
    entities: Array<string>;
    tags: Array<string>;
    type: AlertPolicyTypeEnum;
    uuid: string;
    value: number;
    window: AlertPolicyWindowEnum;
}
export declare const AlertPolicyCompareEnum: {
    readonly GreaterThan: "GreaterThan";
    readonly LessThan: "LessThan";
};
export type AlertPolicyCompareEnum = (typeof AlertPolicyCompareEnum)[keyof typeof AlertPolicyCompareEnum];
export declare const AlertPolicyTypeEnum: {
    readonly InsightsDropletLoad1: "v1/insights/droplet/load_1";
    readonly InsightsDropletLoad5: "v1/insights/droplet/load_5";
    readonly InsightsDropletLoad15: "v1/insights/droplet/load_15";
    readonly InsightsDropletMemoryUtilizationPercent: "v1/insights/droplet/memory_utilization_percent";
    readonly InsightsDropletDiskUtilizationPercent: "v1/insights/droplet/disk_utilization_percent";
    readonly InsightsDropletCpu: "v1/insights/droplet/cpu";
    readonly InsightsDropletDiskRead: "v1/insights/droplet/disk_read";
    readonly InsightsDropletDiskWrite: "v1/insights/droplet/disk_write";
    readonly InsightsDropletPublicOutboundBandwidth: "v1/insights/droplet/public_outbound_bandwidth";
    readonly InsightsDropletPublicInboundBandwidth: "v1/insights/droplet/public_inbound_bandwidth";
    readonly InsightsDropletPrivateOutboundBandwidth: "v1/insights/droplet/private_outbound_bandwidth";
    readonly InsightsDropletPrivateInboundBandwidth: "v1/insights/droplet/private_inbound_bandwidth";
    readonly InsightsLbaasAvgCpuUtilizationPercent: "v1/insights/lbaas/avg_cpu_utilization_percent";
    readonly InsightsLbaasConnectionUtilizationPercent: "v1/insights/lbaas/connection_utilization_percent";
    readonly InsightsLbaasDropletHealth: "v1/insights/lbaas/droplet_health";
    readonly InsightsLbaasTlsConnectionsPerSecondUtilizationPercent: "v1/insights/lbaas/tls_connections_per_second_utilization_percent";
    readonly InsightsLbaasIncreaseInHttpErrorRatePercentage5xx: "v1/insights/lbaas/increase_in_http_error_rate_percentage_5xx";
    readonly InsightsLbaasIncreaseInHttpErrorRatePercentage4xx: "v1/insights/lbaas/increase_in_http_error_rate_percentage_4xx";
    readonly InsightsLbaasIncreaseInHttpErrorRateCount5xx: "v1/insights/lbaas/increase_in_http_error_rate_count_5xx";
    readonly InsightsLbaasIncreaseInHttpErrorRateCount4xx: "v1/insights/lbaas/increase_in_http_error_rate_count_4xx";
    readonly InsightsLbaasHighHttpRequestResponseTime: "v1/insights/lbaas/high_http_request_response_time";
    readonly InsightsLbaasHighHttpRequestResponseTime50p: "v1/insights/lbaas/high_http_request_response_time_50p";
    readonly InsightsLbaasHighHttpRequestResponseTime95p: "v1/insights/lbaas/high_http_request_response_time_95p";
    readonly InsightsLbaasHighHttpRequestResponseTime99p: "v1/insights/lbaas/high_http_request_response_time_99p";
    readonly DbaasAlertsLoad15Alerts: "v1/dbaas/alerts/load_15_alerts";
    readonly DbaasAlertsMemoryUtilizationAlerts: "v1/dbaas/alerts/memory_utilization_alerts";
    readonly DbaasAlertsDiskUtilizationAlerts: "v1/dbaas/alerts/disk_utilization_alerts";
    readonly DbaasAlertsCpuAlerts: "v1/dbaas/alerts/cpu_alerts";
};
export type AlertPolicyTypeEnum = (typeof AlertPolicyTypeEnum)[keyof typeof AlertPolicyTypeEnum];
export declare const AlertPolicyWindowEnum: {
    readonly _5m: "5m";
    readonly _10m: "10m";
    readonly _30m: "30m";
    readonly _1h: "1h";
};
export type AlertPolicyWindowEnum = (typeof AlertPolicyWindowEnum)[keyof typeof AlertPolicyWindowEnum];
export interface AlertPolicyRequest {
    alerts: Alerts;
    compare: AlertPolicyRequestCompareEnum;
    description: string;
    enabled: boolean;
    entities: Array<string>;
    tags: Array<string>;
    type: AlertPolicyRequestTypeEnum;
    value: number;
    window: AlertPolicyRequestWindowEnum;
}
export declare const AlertPolicyRequestCompareEnum: {
    readonly GreaterThan: "GreaterThan";
    readonly LessThan: "LessThan";
};
export type AlertPolicyRequestCompareEnum = (typeof AlertPolicyRequestCompareEnum)[keyof typeof AlertPolicyRequestCompareEnum];
export declare const AlertPolicyRequestTypeEnum: {
    readonly InsightsDropletLoad1: "v1/insights/droplet/load_1";
    readonly InsightsDropletLoad5: "v1/insights/droplet/load_5";
    readonly InsightsDropletLoad15: "v1/insights/droplet/load_15";
    readonly InsightsDropletMemoryUtilizationPercent: "v1/insights/droplet/memory_utilization_percent";
    readonly InsightsDropletDiskUtilizationPercent: "v1/insights/droplet/disk_utilization_percent";
    readonly InsightsDropletCpu: "v1/insights/droplet/cpu";
    readonly InsightsDropletDiskRead: "v1/insights/droplet/disk_read";
    readonly InsightsDropletDiskWrite: "v1/insights/droplet/disk_write";
    readonly InsightsDropletPublicOutboundBandwidth: "v1/insights/droplet/public_outbound_bandwidth";
    readonly InsightsDropletPublicInboundBandwidth: "v1/insights/droplet/public_inbound_bandwidth";
    readonly InsightsDropletPrivateOutboundBandwidth: "v1/insights/droplet/private_outbound_bandwidth";
    readonly InsightsDropletPrivateInboundBandwidth: "v1/insights/droplet/private_inbound_bandwidth";
    readonly InsightsLbaasAvgCpuUtilizationPercent: "v1/insights/lbaas/avg_cpu_utilization_percent";
    readonly InsightsLbaasConnectionUtilizationPercent: "v1/insights/lbaas/connection_utilization_percent";
    readonly InsightsLbaasDropletHealth: "v1/insights/lbaas/droplet_health";
    readonly InsightsLbaasTlsConnectionsPerSecondUtilizationPercent: "v1/insights/lbaas/tls_connections_per_second_utilization_percent";
    readonly InsightsLbaasIncreaseInHttpErrorRatePercentage5xx: "v1/insights/lbaas/increase_in_http_error_rate_percentage_5xx";
    readonly InsightsLbaasIncreaseInHttpErrorRatePercentage4xx: "v1/insights/lbaas/increase_in_http_error_rate_percentage_4xx";
    readonly InsightsLbaasIncreaseInHttpErrorRateCount5xx: "v1/insights/lbaas/increase_in_http_error_rate_count_5xx";
    readonly InsightsLbaasIncreaseInHttpErrorRateCount4xx: "v1/insights/lbaas/increase_in_http_error_rate_count_4xx";
    readonly InsightsLbaasHighHttpRequestResponseTime: "v1/insights/lbaas/high_http_request_response_time";
    readonly InsightsLbaasHighHttpRequestResponseTime50p: "v1/insights/lbaas/high_http_request_response_time_50p";
    readonly InsightsLbaasHighHttpRequestResponseTime95p: "v1/insights/lbaas/high_http_request_response_time_95p";
    readonly InsightsLbaasHighHttpRequestResponseTime99p: "v1/insights/lbaas/high_http_request_response_time_99p";
    readonly DbaasAlertsLoad15Alerts: "v1/dbaas/alerts/load_15_alerts";
    readonly DbaasAlertsMemoryUtilizationAlerts: "v1/dbaas/alerts/memory_utilization_alerts";
    readonly DbaasAlertsDiskUtilizationAlerts: "v1/dbaas/alerts/disk_utilization_alerts";
    readonly DbaasAlertsCpuAlerts: "v1/dbaas/alerts/cpu_alerts";
};
export type AlertPolicyRequestTypeEnum = (typeof AlertPolicyRequestTypeEnum)[keyof typeof AlertPolicyRequestTypeEnum];
export declare const AlertPolicyRequestWindowEnum: {
    readonly _5m: "5m";
    readonly _10m: "10m";
    readonly _30m: "30m";
    readonly _1h: "1h";
};
export type AlertPolicyRequestWindowEnum = (typeof AlertPolicyRequestWindowEnum)[keyof typeof AlertPolicyRequestWindowEnum];
export interface AlertUpdatable {
    name?: string;
    type?: AlertUpdatableTypeEnum;
    threshold?: number;
    comparison?: AlertUpdatableComparisonEnum;
    notifications?: Notification;
    period?: AlertUpdatablePeriodEnum;
}
export declare const AlertUpdatableTypeEnum: {
    readonly Latency: "latency";
    readonly Down: "down";
    readonly DownGlobal: "down_global";
    readonly SslExpiry: "ssl_expiry";
};
export type AlertUpdatableTypeEnum = (typeof AlertUpdatableTypeEnum)[keyof typeof AlertUpdatableTypeEnum];
export declare const AlertUpdatableComparisonEnum: {
    readonly GreaterThan: "greater_than";
    readonly LessThan: "less_than";
};
export type AlertUpdatableComparisonEnum = (typeof AlertUpdatableComparisonEnum)[keyof typeof AlertUpdatableComparisonEnum];
export declare const AlertUpdatablePeriodEnum: {
    readonly _2m: "2m";
    readonly _3m: "3m";
    readonly _5m: "5m";
    readonly _10m: "10m";
    readonly _15m: "15m";
    readonly _30m: "30m";
    readonly _1h: "1h";
};
export type AlertUpdatablePeriodEnum = (typeof AlertUpdatablePeriodEnum)[keyof typeof AlertUpdatablePeriodEnum];
export interface Alerts {
    email: Array<string>;
    slack: Array<SlackDetails>;
}
export interface App {
    active_deployment?: AppsDeployment;
    created_at?: string;
    default_ingress?: string;
    domains?: Array<AppsDomain>;
    id?: string;
    in_progress_deployment?: AppsDeployment;
    last_deployment_created_at?: string;
    live_domain?: string;
    live_url?: string;
    live_url_base?: string;
    owner_uuid?: string;
    pending_deployment?: AppPendingDeployment;
    project_id?: string;
    region?: AppsRegion;
    spec: AppSpec;
    tier_slug?: string;
    updated_at?: string;
    pinned_deployment?: AppPinnedDeployment;
    dedicated_ips?: Array<AppsDedicatedEgressIp>;
}
export interface AppAlert {
    id?: string;
    component_name?: string;
    spec?: AppAlertSpec;
    emails?: Array<string>;
    slack_webhooks?: Array<AppAlertSlackWebhook>;
    phase?: AppAlertPhase;
    progress?: AppAlertProgress;
}
export declare const AppAlertPhase: {
    readonly Unknown: "UNKNOWN";
    readonly Pending: "PENDING";
    readonly Configuring: "CONFIGURING";
    readonly Active: "ACTIVE";
    readonly Error: "ERROR";
};
export type AppAlertPhase = (typeof AppAlertPhase)[keyof typeof AppAlertPhase];
export interface AppAlertProgress {
    steps?: Array<AppAlertProgressStep>;
}
export interface AppAlertProgressStep {
    name?: string;
    status?: AppAlertProgressStepStatus;
    started_at?: string;
    ended_at?: string;
    reason?: AppAlertProgressStepReason;
}
export interface AppAlertProgressStepReason {
    code?: string;
    message?: string;
}
export declare const AppAlertProgressStepStatus: {
    readonly Unknown: "UNKNOWN";
    readonly Pending: "PENDING";
    readonly Running: "RUNNING";
    readonly Error: "ERROR";
    readonly Success: "SUCCESS";
};
export type AppAlertProgressStepStatus = (typeof AppAlertProgressStepStatus)[keyof typeof AppAlertProgressStepStatus];
export interface AppAlertSlackWebhook {
    url?: string;
    channel?: string;
}
export interface AppAlertSpec {
    rule?: AppAlertSpecRule;
    disabled?: boolean;
    operator?: AppAlertSpecOperator;
    value?: number;
    window?: AppAlertSpecWindow;
}
export declare const AppAlertSpecOperator: {
    readonly UnspecifiedOperator: "UNSPECIFIED_OPERATOR";
    readonly GreaterThan: "GREATER_THAN";
    readonly LessThan: "LESS_THAN";
};
export type AppAlertSpecOperator = (typeof AppAlertSpecOperator)[keyof typeof AppAlertSpecOperator];
export declare const AppAlertSpecRule: {
    readonly UnspecifiedRule: "UNSPECIFIED_RULE";
    readonly CpuUtilization: "CPU_UTILIZATION";
    readonly MemUtilization: "MEM_UTILIZATION";
    readonly RestartCount: "RESTART_COUNT";
    readonly DeploymentFailed: "DEPLOYMENT_FAILED";
    readonly DeploymentLive: "DEPLOYMENT_LIVE";
    readonly DomainFailed: "DOMAIN_FAILED";
    readonly DomainLive: "DOMAIN_LIVE";
    readonly FunctionsActivationCount: "FUNCTIONS_ACTIVATION_COUNT";
    readonly FunctionsAverageDurationMs: "FUNCTIONS_AVERAGE_DURATION_MS";
    readonly FunctionsErrorRatePerMinute: "FUNCTIONS_ERROR_RATE_PER_MINUTE";
    readonly FunctionsAverageWaitTimeMs: "FUNCTIONS_AVERAGE_WAIT_TIME_MS";
    readonly FunctionsErrorCount: "FUNCTIONS_ERROR_COUNT";
    readonly FunctionsGbRatePerSecond: "FUNCTIONS_GB_RATE_PER_SECOND";
};
export type AppAlertSpecRule = (typeof AppAlertSpecRule)[keyof typeof AppAlertSpecRule];
export declare const AppAlertSpecWindow: {
    readonly UnspecifiedWindow: "UNSPECIFIED_WINDOW";
    readonly FiveMinutes: "FIVE_MINUTES";
    readonly TenMinutes: "TEN_MINUTES";
    readonly ThirtyMinutes: "THIRTY_MINUTES";
    readonly OneHour: "ONE_HOUR";
};
export type AppAlertSpecWindow = (typeof AppAlertSpecWindow)[keyof typeof AppAlertSpecWindow];
export interface AppComponentBase {
    name?: string;
    git?: AppsGitSourceSpec;
    github?: AppsGithubSourceSpec;
    gitlab?: AppsGitlabSourceSpec;
    image?: AppsImageSourceSpec;
    dockerfile_path?: string;
    build_command?: string;
    run_command?: string;
    source_dir?: string;
    envs?: Array<AppVariableDefinition>;
    environment_slug?: string;
    log_destinations?: Array<AppLogDestinationDefinition>;
}
export interface AppComponentInstanceBase {
    instance_count?: number;
    instance_size_slug?: AppComponentInstanceBaseInstanceSizeSlugEnum;
    autoscaling?: AppComponentInstanceBaseAutoscaling;
}
export declare const AppComponentInstanceBaseInstanceSizeSlugEnum: {
    readonly S1vcpu05gb: "apps-s-1vcpu-0.5gb";
    readonly S1vcpu1gbFixed: "apps-s-1vcpu-1gb-fixed";
    readonly S1vcpu1gb: "apps-s-1vcpu-1gb";
    readonly S1vcpu2gb: "apps-s-1vcpu-2gb";
    readonly S2vcpu4gb: "apps-s-2vcpu-4gb";
    readonly D1vcpu05gb: "apps-d-1vcpu-0.5gb";
    readonly D1vcpu1gb: "apps-d-1vcpu-1gb";
    readonly D1vcpu2gb: "apps-d-1vcpu-2gb";
    readonly D1vcpu4gb: "apps-d-1vcpu-4gb";
    readonly D2vcpu4gb: "apps-d-2vcpu-4gb";
    readonly D2vcpu8gb: "apps-d-2vcpu-8gb";
    readonly D4vcpu8gb: "apps-d-4vcpu-8gb";
    readonly D4vcpu16gb: "apps-d-4vcpu-16gb";
    readonly D8vcpu32gb: "apps-d-8vcpu-32gb";
};
export type AppComponentInstanceBaseInstanceSizeSlugEnum = (typeof AppComponentInstanceBaseInstanceSizeSlugEnum)[keyof typeof AppComponentInstanceBaseInstanceSizeSlugEnum];
export interface AppComponentInstanceBaseAutoscaling {
    min_instance_count?: number;
    max_instance_count?: number;
    metrics?: AppComponentInstanceBaseAutoscalingMetrics;
}
export interface AppComponentInstanceBaseAutoscalingMetrics {
    cpu?: AppComponentInstanceBaseAutoscalingMetricsCpu;
}
export interface AppComponentInstanceBaseAutoscalingMetricsCpu {
    percent?: number;
}
export interface AppDatabaseSpec {
    cluster_name?: string;
    db_name?: string;
    db_user?: string;
    engine?: AppDatabaseSpecEngineEnum;
    name: string;
    production?: boolean;
    version?: string;
}
export declare const AppDatabaseSpecEngineEnum: {
    readonly Unset: "UNSET";
    readonly Mysql: "MYSQL";
    readonly Pg: "PG";
    readonly Redis: "REDIS";
    readonly Mongodb: "MONGODB";
    readonly Kafka: "KAFKA";
    readonly Opensearch: "OPENSEARCH";
};
export type AppDatabaseSpecEngineEnum = (typeof AppDatabaseSpecEngineEnum)[keyof typeof AppDatabaseSpecEngineEnum];
export interface AppDomainSpec {
    domain: string;
    type?: AppDomainSpecTypeEnum;
    wildcard?: boolean;
    zone?: string;
    minimum_tls_version?: AppDomainSpecMinimumTlsVersionEnum;
}
export declare const AppDomainSpecTypeEnum: {
    readonly Unspecified: "UNSPECIFIED";
    readonly Default: "DEFAULT";
    readonly Primary: "PRIMARY";
    readonly Alias: "ALIAS";
};
export type AppDomainSpecTypeEnum = (typeof AppDomainSpecTypeEnum)[keyof typeof AppDomainSpecTypeEnum];
export declare const AppDomainSpecMinimumTlsVersionEnum: {
    readonly _2: "1.2";
    readonly _3: "1.3";
};
export type AppDomainSpecMinimumTlsVersionEnum = (typeof AppDomainSpecMinimumTlsVersionEnum)[keyof typeof AppDomainSpecMinimumTlsVersionEnum];
export interface AppDomainValidation {
    txt_name?: string;
    txt_value?: string;
}
export interface AppEgressSpec {
    type?: AppEgressTypeSpec;
}
export declare const AppEgressTypeSpec: {
    readonly Autoassign: "AUTOASSIGN";
    readonly DedicatedIp: "DEDICATED_IP";
};
export type AppEgressTypeSpec = (typeof AppEgressTypeSpec)[keyof typeof AppEgressTypeSpec];
export interface AppFunctionsSpec {
    cors?: AppStaticSiteSpecAllOfCors;
    routes?: Array<AppRouteSpec>;
    name: string;
    source_dir?: string;
    alerts?: Array<AppAlertSpec>;
    envs?: Array<AppVariableDefinition>;
    git?: AppsGitSourceSpec;
    github?: AppsGithubSourceSpec;
    gitlab?: AppsGitlabSourceSpec;
    log_destinations?: Array<AppLogDestinationDefinition>;
}
export interface AppIngressSpec {
    rules?: Array<AppIngressSpecRule>;
}
export interface AppIngressSpecRule {
    match?: AppIngressSpecRuleMatch;
    cors?: AppsCorsPolicy;
    component?: AppIngressSpecRuleRoutingComponent;
    redirect?: AppIngressSpecRuleRoutingRedirect;
}
export interface AppIngressSpecRuleMatch {
    path: AppIngressSpecRuleStringMatch;
}
export interface AppIngressSpecRuleRoutingComponent {
    name: string;
    preserve_path_prefix?: string;
    rewrite?: string;
}
export interface AppIngressSpecRuleRoutingRedirect {
    uri?: string;
    authority?: string;
    port?: number;
    scheme?: string;
    redirect_code?: number;
}
export interface AppIngressSpecRuleStringMatch {
    prefix: string;
}
export interface AppJobSpec {
    name: string;
    git?: AppsGitSourceSpec;
    github?: AppsGithubSourceSpec;
    gitlab?: AppsGitlabSourceSpec;
    image?: AppsImageSourceSpec;
    dockerfile_path?: string;
    build_command?: string;
    run_command?: string;
    source_dir?: string;
    envs?: Array<AppVariableDefinition>;
    environment_slug?: string;
    log_destinations?: Array<AppLogDestinationDefinition>;
    instance_count?: number;
    instance_size_slug?: AppJobSpecInstanceSizeSlugEnum;
    autoscaling?: AppComponentInstanceBaseAutoscaling;
    kind?: AppJobSpecKindEnum;
    termination?: AppJobSpecTermination;
}
export declare const AppJobSpecInstanceSizeSlugEnum: {
    readonly S1vcpu05gb: "apps-s-1vcpu-0.5gb";
    readonly S1vcpu1gbFixed: "apps-s-1vcpu-1gb-fixed";
    readonly S1vcpu1gb: "apps-s-1vcpu-1gb";
    readonly S1vcpu2gb: "apps-s-1vcpu-2gb";
    readonly S2vcpu4gb: "apps-s-2vcpu-4gb";
    readonly D1vcpu05gb: "apps-d-1vcpu-0.5gb";
    readonly D1vcpu1gb: "apps-d-1vcpu-1gb";
    readonly D1vcpu2gb: "apps-d-1vcpu-2gb";
    readonly D1vcpu4gb: "apps-d-1vcpu-4gb";
    readonly D2vcpu4gb: "apps-d-2vcpu-4gb";
    readonly D2vcpu8gb: "apps-d-2vcpu-8gb";
    readonly D4vcpu8gb: "apps-d-4vcpu-8gb";
    readonly D4vcpu16gb: "apps-d-4vcpu-16gb";
    readonly D8vcpu32gb: "apps-d-8vcpu-32gb";
};
export type AppJobSpecInstanceSizeSlugEnum = (typeof AppJobSpecInstanceSizeSlugEnum)[keyof typeof AppJobSpecInstanceSizeSlugEnum];
export declare const AppJobSpecKindEnum: {
    readonly Unspecified: "UNSPECIFIED";
    readonly PreDeploy: "PRE_DEPLOY";
    readonly PostDeploy: "POST_DEPLOY";
    readonly FailedDeploy: "FAILED_DEPLOY";
};
export type AppJobSpecKindEnum = (typeof AppJobSpecKindEnum)[keyof typeof AppJobSpecKindEnum];
export interface AppJobSpecTermination {
    grace_period_seconds?: number;
}
export interface AppLogDestinationDatadogSpec {
    endpoint?: string;
    api_key: string;
}
export interface AppLogDestinationDefinition {
    name: string;
    papertrail?: AppLogDestinationPapertrailSpec;
    datadog?: AppLogDestinationDatadogSpec;
    logtail?: AppLogDestinationLogtailSpec;
    open_search?: AppLogDestinationOpenSearchSpec;
}
export interface AppLogDestinationLogtailSpec {
    token?: string;
}
export interface AppLogDestinationOpenSearchSpec {
    endpoint?: string;
    basic_auth?: AppLogDestinationOpenSearchSpecBasicAuth;
    index_name?: string;
    cluster_name?: string;
}
export interface AppLogDestinationOpenSearchSpecBasicAuth {
    user?: string;
    password?: any;
}
export interface AppLogDestinationPapertrailSpec {
    endpoint: string;
}
export interface AppMetricsBandwidthUsage {
    app_bandwidth_usage?: Array<AppMetricsBandwidthUsageDetails>;
    date?: string;
}
export interface AppMetricsBandwidthUsageDetails {
    app_id?: string;
    bandwidth_bytes?: string;
}
export interface AppMetricsBandwidthUsageRequest {
    app_ids: Array<string>;
    date?: string;
}
export interface AppPendingDeployment {
    cause?: string;
    cloned_from?: string;
    created_at?: string;
    id?: string;
    jobs?: Array<AppsDeploymentJob>;
    functions?: Array<AppsDeploymentFunctions>;
    phase?: AppsDeploymentPhase;
    phase_last_updated_at?: string;
    progress?: AppsDeploymentProgress;
    services?: Array<AppsDeploymentService>;
    spec?: AppSpec;
    static_sites?: Array<AppsDeploymentStaticSite>;
    tier_slug?: string;
    updated_at?: string;
    workers?: Array<AppsDeploymentWorker>;
}
export interface AppPinnedDeployment {
    cause?: string;
    cloned_from?: string;
    created_at?: string;
    id?: string;
    jobs?: Array<AppsDeploymentJob>;
    functions?: Array<AppsDeploymentFunctions>;
    phase?: AppsDeploymentPhase;
    phase_last_updated_at?: string;
    progress?: AppsDeploymentProgress;
    services?: Array<AppsDeploymentService>;
    spec?: AppSpec;
    static_sites?: Array<AppsDeploymentStaticSite>;
    tier_slug?: string;
    updated_at?: string;
    workers?: Array<AppsDeploymentWorker>;
}
export interface AppPropose {
    spec: AppSpec;
    app_id?: string;
}
export interface AppProposeResponse {
    app_is_static?: boolean;
    app_name_available?: boolean;
    app_name_suggestion?: string;
    existing_static_apps?: string;
    spec?: AppSpec;
    app_cost?: number;
    app_tier_downgrade_cost?: number;
}
export interface AppResponse {
    app?: App;
}
export interface AppRollbackValidationCondition {
    code?: AppRollbackValidationConditionCodeEnum;
    message?: string;
    components?: Array<string>;
}
export declare const AppRollbackValidationConditionCodeEnum: {
    readonly IncompatiblePhase: "incompatible_phase";
    readonly IncompatibleResult: "incompatible_result";
    readonly ExceededRevisionLimit: "exceeded_revision_limit";
    readonly AppPinned: "app_pinned";
    readonly DatabaseConfigConflict: "database_config_conflict";
    readonly RegionConflict: "region_conflict";
    readonly StaticSiteRequiresRebuild: "static_site_requires_rebuild";
    readonly ImageSourceMissingDigest: "image_source_missing_digest";
};
export type AppRollbackValidationConditionCodeEnum = (typeof AppRollbackValidationConditionCodeEnum)[keyof typeof AppRollbackValidationConditionCodeEnum];
export interface AppRouteSpec {
    path?: string;
    preserve_path_prefix?: boolean;
}
export interface AppServiceSpec {
    name: string;
    git?: AppsGitSourceSpec;
    github?: AppsGithubSourceSpec;
    gitlab?: AppsGitlabSourceSpec;
    image?: AppsImageSourceSpec;
    dockerfile_path?: string;
    build_command?: string;
    run_command?: string;
    source_dir?: string;
    envs?: Array<AppVariableDefinition>;
    environment_slug?: string;
    log_destinations?: Array<AppLogDestinationDefinition>;
    instance_count?: number;
    instance_size_slug?: AppServiceSpecInstanceSizeSlugEnum;
    autoscaling?: AppComponentInstanceBaseAutoscaling;
    cors?: AppServiceSpecAllOfCors;
    health_check?: AppServiceSpecHealthCheck;
    http_port?: number;
    internal_ports?: Array<number>;
    routes?: Array<AppRouteSpec>;
    termination?: AppServiceSpecTermination;
}
export declare const AppServiceSpecInstanceSizeSlugEnum: {
    readonly S1vcpu05gb: "apps-s-1vcpu-0.5gb";
    readonly S1vcpu1gbFixed: "apps-s-1vcpu-1gb-fixed";
    readonly S1vcpu1gb: "apps-s-1vcpu-1gb";
    readonly S1vcpu2gb: "apps-s-1vcpu-2gb";
    readonly S2vcpu4gb: "apps-s-2vcpu-4gb";
    readonly D1vcpu05gb: "apps-d-1vcpu-0.5gb";
    readonly D1vcpu1gb: "apps-d-1vcpu-1gb";
    readonly D1vcpu2gb: "apps-d-1vcpu-2gb";
    readonly D1vcpu4gb: "apps-d-1vcpu-4gb";
    readonly D2vcpu4gb: "apps-d-2vcpu-4gb";
    readonly D2vcpu8gb: "apps-d-2vcpu-8gb";
    readonly D4vcpu8gb: "apps-d-4vcpu-8gb";
    readonly D4vcpu16gb: "apps-d-4vcpu-16gb";
    readonly D8vcpu32gb: "apps-d-8vcpu-32gb";
};
export type AppServiceSpecInstanceSizeSlugEnum = (typeof AppServiceSpecInstanceSizeSlugEnum)[keyof typeof AppServiceSpecInstanceSizeSlugEnum];
export interface AppServiceSpecAllOfCors {
    allow_origins?: Array<AppsStringMatch>;
    allow_methods?: Array<string>;
    allow_headers?: Array<string>;
    expose_headers?: Array<string>;
    max_age?: string;
    allow_credentials?: boolean;
}
export interface AppServiceSpecHealthCheck {
    failure_threshold?: number;
    port?: number;
    http_path?: string;
    initial_delay_seconds?: number;
    period_seconds?: number;
    success_threshold?: number;
    timeout_seconds?: number;
}
export interface AppServiceSpecTermination {
    drain_seconds?: number;
    grace_period_seconds?: number;
}
export interface AppSpec {
    name: string;
    region?: AppSpecRegionEnum;
    domains?: Array<AppDomainSpec>;
    services?: Array<AppServiceSpec>;
    static_sites?: Array<AppStaticSiteSpec>;
    jobs?: Array<AppJobSpec>;
    workers?: Array<AppWorkerSpec>;
    functions?: Array<AppFunctionsSpec>;
    databases?: Array<AppDatabaseSpec>;
    ingress?: AppIngressSpec;
    egress?: AppEgressSpec;
}
export declare const AppSpecRegionEnum: {
    readonly Ams: "ams";
    readonly Nyc: "nyc";
    readonly Fra: "fra";
    readonly Sfo: "sfo";
    readonly Sgp: "sgp";
    readonly Blr: "blr";
    readonly Tor: "tor";
    readonly Lon: "lon";
    readonly Syd: "syd";
};
export type AppSpecRegionEnum = (typeof AppSpecRegionEnum)[keyof typeof AppSpecRegionEnum];
export interface AppStaticSiteSpec {
    name: string;
    git?: AppsGitSourceSpec;
    github?: AppsGithubSourceSpec;
    gitlab?: AppsGitlabSourceSpec;
    image?: AppsImageSourceSpec;
    dockerfile_path?: string;
    build_command?: string;
    run_command?: string;
    source_dir?: string;
    envs?: Array<AppVariableDefinition>;
    environment_slug?: string;
    log_destinations?: Array<AppLogDestinationDefinition>;
    index_document?: string;
    error_document?: string;
    catchall_document?: string;
    output_dir?: string;
    cors?: AppStaticSiteSpecAllOfCors;
    routes?: Array<AppRouteSpec>;
}
export interface AppStaticSiteSpecAllOfCors {
    allow_origins?: Array<AppsStringMatch>;
    allow_methods?: Array<string>;
    allow_headers?: Array<string>;
    expose_headers?: Array<string>;
    max_age?: string;
    allow_credentials?: boolean;
}
export interface AppVariableDefinition {
    key: string;
    scope?: AppVariableDefinitionScopeEnum;
    type?: AppVariableDefinitionTypeEnum;
    value?: string;
}
export declare const AppVariableDefinitionScopeEnum: {
    readonly Unset: "UNSET";
    readonly RunTime: "RUN_TIME";
    readonly BuildTime: "BUILD_TIME";
    readonly RunAndBuildTime: "RUN_AND_BUILD_TIME";
};
export type AppVariableDefinitionScopeEnum = (typeof AppVariableDefinitionScopeEnum)[keyof typeof AppVariableDefinitionScopeEnum];
export declare const AppVariableDefinitionTypeEnum: {
    readonly General: "GENERAL";
    readonly Secret: "SECRET";
};
export type AppVariableDefinitionTypeEnum = (typeof AppVariableDefinitionTypeEnum)[keyof typeof AppVariableDefinitionTypeEnum];
export interface AppWorkerSpec {
    name: string;
    git?: AppsGitSourceSpec;
    github?: AppsGithubSourceSpec;
    gitlab?: AppsGitlabSourceSpec;
    image?: AppsImageSourceSpec;
    dockerfile_path?: string;
    build_command?: string;
    run_command?: string;
    source_dir?: string;
    envs?: Array<AppVariableDefinition>;
    environment_slug?: string;
    log_destinations?: Array<AppLogDestinationDefinition>;
    instance_count?: number;
    instance_size_slug?: AppWorkerSpecInstanceSizeSlugEnum;
    autoscaling?: AppComponentInstanceBaseAutoscaling;
    termination?: AppWorkerSpecTermination;
}
export declare const AppWorkerSpecInstanceSizeSlugEnum: {
    readonly S1vcpu05gb: "apps-s-1vcpu-0.5gb";
    readonly S1vcpu1gbFixed: "apps-s-1vcpu-1gb-fixed";
    readonly S1vcpu1gb: "apps-s-1vcpu-1gb";
    readonly S1vcpu2gb: "apps-s-1vcpu-2gb";
    readonly S2vcpu4gb: "apps-s-2vcpu-4gb";
    readonly D1vcpu05gb: "apps-d-1vcpu-0.5gb";
    readonly D1vcpu1gb: "apps-d-1vcpu-1gb";
    readonly D1vcpu2gb: "apps-d-1vcpu-2gb";
    readonly D1vcpu4gb: "apps-d-1vcpu-4gb";
    readonly D2vcpu4gb: "apps-d-2vcpu-4gb";
    readonly D2vcpu8gb: "apps-d-2vcpu-8gb";
    readonly D4vcpu8gb: "apps-d-4vcpu-8gb";
    readonly D4vcpu16gb: "apps-d-4vcpu-16gb";
    readonly D8vcpu32gb: "apps-d-8vcpu-32gb";
};
export type AppWorkerSpecInstanceSizeSlugEnum = (typeof AppWorkerSpecInstanceSizeSlugEnum)[keyof typeof AppWorkerSpecInstanceSizeSlugEnum];
export interface AppWorkerSpecTermination {
    grace_period_seconds?: number;
}
export interface AppsAlertResponse {
    alert?: AppAlert;
}
export interface AppsAssignAppAlertDestinationsRequest {
    emails?: Array<string>;
    slack_webhooks?: Array<AppAlertSlackWebhook>;
}
export interface AppsCorsPolicy {
    allow_origins?: Array<AppsStringMatch>;
    allow_methods?: Array<string>;
    allow_headers?: Array<string>;
    expose_headers?: Array<string>;
    max_age?: string;
    allow_credentials?: boolean;
}
export interface AppsCreateAppRequest {
    spec: AppSpec;
    project_id?: string;
}
export interface AppsCreateDeploymentRequest {
    force_build?: boolean;
}
export interface AppsDedicatedEgressIp {
    ip?: string;
    id?: string;
    status?: AppsDedicatedEgressIpStatus;
}
export declare const AppsDedicatedEgressIpStatus: {
    readonly Unknown: "UNKNOWN";
    readonly Assigning: "ASSIGNING";
    readonly Assigned: "ASSIGNED";
    readonly Removed: "REMOVED";
};
export type AppsDedicatedEgressIpStatus = (typeof AppsDedicatedEgressIpStatus)[keyof typeof AppsDedicatedEgressIpStatus];
export interface AppsDeleteAppResponse {
    id?: string;
}
export interface AppsDeployment {
    cause?: string;
    cloned_from?: string;
    created_at?: string;
    id?: string;
    jobs?: Array<AppsDeploymentJob>;
    functions?: Array<AppsDeploymentFunctions>;
    phase?: AppsDeploymentPhase;
    phase_last_updated_at?: string;
    progress?: AppsDeploymentProgress;
    services?: Array<AppsDeploymentService>;
    spec?: AppSpec;
    static_sites?: Array<AppsDeploymentStaticSite>;
    tier_slug?: string;
    updated_at?: string;
    workers?: Array<AppsDeploymentWorker>;
}
export interface AppsDeploymentFunctions {
    name?: string;
    source_commit_hash?: string;
    namespace?: string;
}
export interface AppsDeploymentJob {
    name?: string;
    source_commit_hash?: string;
}
export declare const AppsDeploymentPhase: {
    readonly Unknown: "UNKNOWN";
    readonly PendingBuild: "PENDING_BUILD";
    readonly Building: "BUILDING";
    readonly PendingDeploy: "PENDING_DEPLOY";
    readonly Deploying: "DEPLOYING";
    readonly Active: "ACTIVE";
    readonly Superseded: "SUPERSEDED";
    readonly Error: "ERROR";
    readonly Canceled: "CANCELED";
};
export type AppsDeploymentPhase = (typeof AppsDeploymentPhase)[keyof typeof AppsDeploymentPhase];
export interface AppsDeploymentProgress {
    error_steps?: number;
    pending_steps?: number;
    running_steps?: number;
    steps?: Array<AppsDeploymentProgressStep>;
    success_steps?: number;
    summary_steps?: Array<AppsDeploymentProgressStep>;
    total_steps?: number;
}
export interface AppsDeploymentProgressStep {
    component_name?: string;
    ended_at?: string;
    message_base?: string;
    name?: string;
    reason?: AppsDeploymentProgressStepReason;
    started_at?: string;
    status?: AppsDeploymentProgressStepStatus;
    steps?: Array<object>;
}
export interface AppsDeploymentProgressStepReason {
    code?: string;
    message?: string;
}
export declare const AppsDeploymentProgressStepStatus: {
    readonly Unknown: "UNKNOWN";
    readonly Pending: "PENDING";
    readonly Running: "RUNNING";
    readonly Error: "ERROR";
    readonly Success: "SUCCESS";
};
export type AppsDeploymentProgressStepStatus = (typeof AppsDeploymentProgressStepStatus)[keyof typeof AppsDeploymentProgressStepStatus];
export interface AppsDeploymentResponse {
    deployment?: AppsDeployment;
}
export interface AppsDeploymentService {
    name?: string;
    source_commit_hash?: string;
}
export interface AppsDeploymentStaticSite {
    name?: string;
    source_commit_hash?: string;
}
export interface AppsDeploymentWorker {
    name?: string;
    source_commit_hash?: string;
}
export interface AppsDeploymentsResponse {
    links?: PageLinks;
    meta: MetaMeta;
    deployments?: Array<AppsDeployment>;
}
export interface AppsDomain {
    id?: string;
    phase?: AppsDomainPhase;
    progress?: AppsDomainProgress;
    spec?: AppDomainSpec;
    validations?: Array<AppDomainValidation>;
    rotate_validation_records?: boolean;
    certificate_expires_at?: string;
}
export declare const AppsDomainPhase: {
    readonly Unknown: "UNKNOWN";
    readonly Pending: "PENDING";
    readonly Configuring: "CONFIGURING";
    readonly Active: "ACTIVE";
    readonly Error: "ERROR";
};
export type AppsDomainPhase = (typeof AppsDomainPhase)[keyof typeof AppsDomainPhase];
export interface AppsDomainProgress {
    steps?: Array<object>;
}
export interface AppsGetInstanceSizeResponse {
    instance_size?: AppsInstanceSize;
}
export interface AppsGetLogsResponse {
    historic_urls?: Array<string>;
    live_url?: string;
}
export interface AppsGitSourceSpec {
    branch?: string;
    repo_clone_url?: string;
}
export interface AppsGithubSourceSpec {
    branch?: string;
    deploy_on_push?: boolean;
    repo?: string;
}
export interface AppsGitlabSourceSpec {
    branch?: string;
    deploy_on_push?: boolean;
    repo?: string;
}
export interface AppsImageSourceSpec {
    registry?: string;
    registry_type?: AppsImageSourceSpecRegistryTypeEnum;
    registry_credentials?: string;
    repository?: string;
    tag?: string;
    digest?: string;
    deploy_on_push?: AppsImageSourceSpecDeployOnPush;
}
export declare const AppsImageSourceSpecRegistryTypeEnum: {
    readonly DockerHub: "DOCKER_HUB";
    readonly Docr: "DOCR";
    readonly Ghcr: "GHCR";
};
export type AppsImageSourceSpecRegistryTypeEnum = (typeof AppsImageSourceSpecRegistryTypeEnum)[keyof typeof AppsImageSourceSpecRegistryTypeEnum];
export interface AppsImageSourceSpecDeployOnPush {
    enabled?: boolean;
}
export interface AppsInstanceSize {
    bandwidth_allowance_gib?: string;
    cpu_type?: InstanceSizeCpuType;
    cpus?: string;
    deprecation_intent?: boolean;
    memory_bytes?: string;
    name?: string;
    scalable?: boolean;
    single_instance_only?: boolean;
    slug?: string;
    tier_downgrade_to?: string;
    tier_slug?: string;
    tier_upgrade_to?: string;
    usd_per_month?: string;
    usd_per_second?: string;
}
export interface AppsListAlertsResponse {
    alerts?: Array<AppAlert>;
}
export interface AppsListInstanceSizesResponse {
    discount_percent?: number;
    instance_sizes?: Array<AppsInstanceSize>;
}
export interface AppsListRegionsResponse {
    regions?: Array<AppsRegion>;
}
export interface AppsRegion {
    continent?: string;
    data_centers?: Array<string>;
    default?: boolean;
    disabled?: boolean;
    flag?: string;
    label?: string;
    reason?: string;
    slug?: string;
}
export interface AppsResponse {
    links?: PageLinks;
    meta: MetaMeta;
    apps?: Array<App>;
}
export interface AppsRollbackAppRequest {
    deployment_id?: string;
    skip_pin?: boolean;
}
export interface AppsStringMatch {
    exact?: string;
    prefix?: string;
    regex?: string;
}
export interface AppsUpdateAppRequest {
    spec: AppSpec;
    update_all_source_versions?: boolean;
}
export interface AppsValidateRollback200Response {
    valid?: boolean;
    error?: AppsValidateRollback200ResponseError;
    warnings?: Array<AppRollbackValidationCondition>;
}
export interface AppsValidateRollback200ResponseError {
    code?: AppsValidateRollback200ResponseErrorCodeEnum;
    message?: string;
    components?: Array<string>;
}
export declare const AppsValidateRollback200ResponseErrorCodeEnum: {
    readonly IncompatiblePhase: "incompatible_phase";
    readonly IncompatibleResult: "incompatible_result";
    readonly ExceededRevisionLimit: "exceeded_revision_limit";
    readonly AppPinned: "app_pinned";
    readonly DatabaseConfigConflict: "database_config_conflict";
    readonly RegionConflict: "region_conflict";
    readonly StaticSiteRequiresRebuild: "static_site_requires_rebuild";
    readonly ImageSourceMissingDigest: "image_source_missing_digest";
};
export type AppsValidateRollback200ResponseErrorCodeEnum = (typeof AppsValidateRollback200ResponseErrorCodeEnum)[keyof typeof AppsValidateRollback200ResponseErrorCodeEnum];
export interface AssignDropletsByID {
    id?: string;
    name?: string;
    project_id?: string;
    ip?: string;
    size_unit?: number;
    size?: AssignDropletsByIDSizeEnum;
    algorithm?: AssignDropletsByIDAlgorithmEnum;
    status?: AssignDropletsByIDStatusEnum;
    created_at?: string;
    forwarding_rules: Array<ForwardingRule>;
    health_check?: HealthCheck;
    sticky_sessions?: StickySessions;
    redirect_http_to_https?: boolean;
    enable_proxy_protocol?: boolean;
    enable_backend_keepalive?: boolean;
    http_idle_timeout_seconds?: number;
    vpc_uuid?: string;
    disable_lets_encrypt_dns_records?: boolean;
    firewall?: LbFirewall;
    droplet_ids: Array<number>;
    region: RegionSlug;
}
export declare const AssignDropletsByIDSizeEnum: {
    readonly Small: "lb-small";
    readonly Medium: "lb-medium";
    readonly Large: "lb-large";
};
export type AssignDropletsByIDSizeEnum = (typeof AssignDropletsByIDSizeEnum)[keyof typeof AssignDropletsByIDSizeEnum];
export declare const AssignDropletsByIDAlgorithmEnum: {
    readonly RoundRobin: "round_robin";
    readonly LeastConnections: "least_connections";
};
export type AssignDropletsByIDAlgorithmEnum = (typeof AssignDropletsByIDAlgorithmEnum)[keyof typeof AssignDropletsByIDAlgorithmEnum];
export declare const AssignDropletsByIDStatusEnum: {
    readonly New: "new";
    readonly Active: "active";
    readonly Errored: "errored";
};
export type AssignDropletsByIDStatusEnum = (typeof AssignDropletsByIDStatusEnum)[keyof typeof AssignDropletsByIDStatusEnum];
export interface AssignDropletsByTag {
    id?: string;
    name?: string;
    project_id?: string;
    ip?: string;
    size_unit?: number;
    size?: AssignDropletsByTagSizeEnum;
    algorithm?: AssignDropletsByTagAlgorithmEnum;
    status?: AssignDropletsByTagStatusEnum;
    created_at?: string;
    forwarding_rules: Array<ForwardingRule>;
    health_check?: HealthCheck;
    sticky_sessions?: StickySessions;
    redirect_http_to_https?: boolean;
    enable_proxy_protocol?: boolean;
    enable_backend_keepalive?: boolean;
    http_idle_timeout_seconds?: number;
    vpc_uuid?: string;
    disable_lets_encrypt_dns_records?: boolean;
    firewall?: LbFirewall;
    tag: string;
    region: RegionSlug;
}
export declare const AssignDropletsByTagSizeEnum: {
    readonly Small: "lb-small";
    readonly Medium: "lb-medium";
    readonly Large: "lb-large";
};
export type AssignDropletsByTagSizeEnum = (typeof AssignDropletsByTagSizeEnum)[keyof typeof AssignDropletsByTagSizeEnum];
export declare const AssignDropletsByTagAlgorithmEnum: {
    readonly RoundRobin: "round_robin";
    readonly LeastConnections: "least_connections";
};
export type AssignDropletsByTagAlgorithmEnum = (typeof AssignDropletsByTagAlgorithmEnum)[keyof typeof AssignDropletsByTagAlgorithmEnum];
export declare const AssignDropletsByTagStatusEnum: {
    readonly New: "new";
    readonly Active: "active";
    readonly Errored: "errored";
};
export type AssignDropletsByTagStatusEnum = (typeof AssignDropletsByTagStatusEnum)[keyof typeof AssignDropletsByTagStatusEnum];
export interface AssignToDroplet {
    droplet_id: number;
}
export interface AssignToDroplet1 {
    droplet_id: number;
}
export interface AssociatedKubernetesResource {
    id?: string;
    name?: string;
}
export interface AssociatedKubernetesResources {
    load_balancers?: Array<AssociatedKubernetesResource>;
    volumes?: Array<AssociatedKubernetesResource>;
    volume_snapshots?: Array<AssociatedKubernetesResource>;
}
export interface AssociatedResource {
    id?: string;
    name?: string;
    cost?: string;
}
export interface AssociatedResourceStatus {
    droplet?: DestroyedAssociatedResource;
    resources?: AssociatedResourceStatusResources;
    completed_at?: string;
    failures?: number;
}
export interface AssociatedResourceStatusResources {
    reserved_ips?: Array<DestroyedAssociatedResource>;
    floating_ips?: Array<DestroyedAssociatedResource>;
    snapshots?: Array<DestroyedAssociatedResource>;
    volumes?: Array<DestroyedAssociatedResource>;
    volume_snapshots?: Array<DestroyedAssociatedResource>;
}
export interface Backup {
    created_at: string;
    size_gigabytes: number;
}
export interface BackwardLinks {
    first?: string;
    prev?: string;
}
export interface Balance {
    month_to_date_balance?: string;
    account_balance?: string;
    month_to_date_usage?: string;
    generated_at?: string;
}
export interface BillingAddress {
    address_line1?: string;
    address_line2?: string;
    city?: string;
    region?: string;
    postal_code?: string;
    country_iso2_code?: string;
    created_at?: string;
    updated_at?: string;
}
export interface BillingHistory {
    description?: string;
    amount?: string;
    invoice_id?: string;
    invoice_uuid?: string;
    date?: string;
    type?: BillingHistoryTypeEnum;
}
export declare const BillingHistoryTypeEnum: {
    readonly AchFailure: "ACHFailure";
    readonly Adjustment: "Adjustment";
    readonly AttemptFailed: "AttemptFailed";
    readonly Chargeback: "Chargeback";
    readonly Credit: "Credit";
    readonly CreditExpiration: "CreditExpiration";
    readonly Invoice: "Invoice";
    readonly Payment: "Payment";
    readonly Refund: "Refund";
    readonly Reversal: "Reversal";
};
export type BillingHistoryTypeEnum = (typeof BillingHistoryTypeEnum)[keyof typeof BillingHistoryTypeEnum];
export interface BillingHistoryList200Response {
    links?: PageLinks;
    meta: MetaProperties;
    billing_history?: Array<BillingHistory>;
}
export interface Ca {
    certificate: string;
}
export interface CdnCreateEndpoint201Response {
    endpoint?: CdnEndpoint;
}
export interface CdnEndpoint {
    id?: string;
    origin: string;
    endpoint?: string;
    ttl?: CdnEndpointTtlEnum;
    certificate_id?: string;
    custom_domain?: string;
    created_at?: string;
}
export declare const CdnEndpointTtlEnum: {
    readonly NUMBER_60: 60;
    readonly NUMBER_600: 600;
    readonly NUMBER_3600: 3600;
    readonly NUMBER_86400: 86400;
    readonly NUMBER_604800: 604800;
};
export type CdnEndpointTtlEnum = (typeof CdnEndpointTtlEnum)[keyof typeof CdnEndpointTtlEnum];
export interface CdnListEndpoints200Response {
    links?: PageLinks;
    meta: MetaMeta;
    endpoints?: Array<CdnEndpoint>;
}
export interface Certificate {
    id?: string;
    name?: string;
    not_after?: string;
    sha1_fingerprint?: string;
    created_at?: string;
    dns_names?: Array<string>;
    state?: CertificateStateEnum;
    type?: CertificateTypeEnum;
}
export declare const CertificateStateEnum: {
    readonly Pending: "pending";
    readonly Verified: "verified";
    readonly Error: "error";
};
export type CertificateStateEnum = (typeof CertificateStateEnum)[keyof typeof CertificateStateEnum];
export declare const CertificateTypeEnum: {
    readonly Custom: "custom";
    readonly LetsEncrypt: "lets_encrypt";
};
export type CertificateTypeEnum = (typeof CertificateTypeEnum)[keyof typeof CertificateTypeEnum];
export interface CertificateCreateBase {
    name: string;
    type?: CertificateCreateBaseTypeEnum;
}
export declare const CertificateCreateBaseTypeEnum: {
    readonly Custom: "custom";
    readonly LetsEncrypt: "lets_encrypt";
};
export type CertificateCreateBaseTypeEnum = (typeof CertificateCreateBaseTypeEnum)[keyof typeof CertificateCreateBaseTypeEnum];
export interface CertificateRequestCustom {
    name: string;
    type?: CertificateRequestCustomTypeEnum;
    private_key: string;
    leaf_certificate: string;
    certificate_chain?: string;
}
export declare const CertificateRequestCustomTypeEnum: {
    readonly Custom: "custom";
    readonly LetsEncrypt: "lets_encrypt";
};
export type CertificateRequestCustomTypeEnum = (typeof CertificateRequestCustomTypeEnum)[keyof typeof CertificateRequestCustomTypeEnum];
export interface CertificateRequestLetsEncrypt {
    name: string;
    type?: CertificateRequestLetsEncryptTypeEnum;
    dns_names: Array<string>;
}
export declare const CertificateRequestLetsEncryptTypeEnum: {
    readonly Custom: "custom";
    readonly LetsEncrypt: "lets_encrypt";
};
export type CertificateRequestLetsEncryptTypeEnum = (typeof CertificateRequestLetsEncryptTypeEnum)[keyof typeof CertificateRequestLetsEncryptTypeEnum];
export interface CertificatesCreate201Response {
    certificate?: Certificate;
}
export type CertificatesCreateRequest = CertificateRequestCustom | CertificateRequestLetsEncrypt;
export interface CertificatesList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    certificates?: Array<Certificate>;
}
export interface Check {
    id?: string;
    name?: string;
    type?: CheckTypeEnum;
    target?: string;
    regions?: Array<CheckRegionsEnum>;
    enabled?: boolean;
}
export declare const CheckTypeEnum: {
    readonly Ping: "ping";
    readonly Http: "http";
    readonly Https: "https";
};
export type CheckTypeEnum = (typeof CheckTypeEnum)[keyof typeof CheckTypeEnum];
export declare const CheckRegionsEnum: {
    readonly UsEast: "us_east";
    readonly UsWest: "us_west";
    readonly EuWest: "eu_west";
    readonly SeAsia: "se_asia";
};
export type CheckRegionsEnum = (typeof CheckRegionsEnum)[keyof typeof CheckRegionsEnum];
export interface CheckBase {
    id?: string;
}
export interface CheckUpdatable {
    name?: string;
    type?: CheckUpdatableTypeEnum;
    target?: string;
    regions?: Array<CheckUpdatableRegionsEnum>;
    enabled?: boolean;
}
export declare const CheckUpdatableTypeEnum: {
    readonly Ping: "ping";
    readonly Http: "http";
    readonly Https: "https";
};
export type CheckUpdatableTypeEnum = (typeof CheckUpdatableTypeEnum)[keyof typeof CheckUpdatableTypeEnum];
export declare const CheckUpdatableRegionsEnum: {
    readonly UsEast: "us_east";
    readonly UsWest: "us_west";
    readonly EuWest: "eu_west";
    readonly SeAsia: "se_asia";
};
export type CheckUpdatableRegionsEnum = (typeof CheckUpdatableRegionsEnum)[keyof typeof CheckUpdatableRegionsEnum];
export interface Cluster {
    id?: string;
    name: string;
    region: string;
    version: string;
    cluster_subnet?: string;
    service_subnet?: string;
    vpc_uuid?: string;
    ipv4?: string;
    endpoint?: string;
    tags?: Array<string>;
    node_pools: Array<KubernetesNodePool>;
    maintenance_policy?: MaintenancePolicy | null;
    auto_upgrade?: boolean;
    status?: ClusterStatus;
    created_at?: string;
    updated_at?: string;
    surge_upgrade?: boolean;
    ha?: boolean;
    registry_enabled?: boolean;
    control_plane_firewall?: ControlPlaneFirewall | null;
}
export interface ClusterRegistries {
    cluster_uuids?: Array<string>;
}
export interface ClusterStatus {
    state?: ClusterStatusStateEnum;
    message?: string;
}
export declare const ClusterStatusStateEnum: {
    readonly Running: "running";
    readonly Provisioning: "provisioning";
    readonly Degraded: "degraded";
    readonly Error: "error";
    readonly Deleted: "deleted";
    readonly Upgrading: "upgrading";
    readonly Deleting: "deleting";
};
export type ClusterStatusStateEnum = (typeof ClusterStatusStateEnum)[keyof typeof ClusterStatusStateEnum];
export interface ClusterUpdate {
    name: string;
    tags?: Array<string>;
    maintenance_policy?: MaintenancePolicy | null;
    auto_upgrade?: boolean;
    surge_upgrade?: boolean;
    ha?: boolean;
    control_plane_firewall?: ControlPlaneFirewall | null;
}
export interface ClusterlintRequest {
    include_groups?: Array<string>;
    include_checks?: Array<string>;
    exclude_groups?: Array<string>;
    exclude_checks?: Array<string>;
}
export interface ClusterlintResults {
    run_id?: string;
    requested_at?: string;
    completed_at?: string;
    diagnostics?: Array<ClusterlintResultsDiagnosticsInner>;
}
export interface ClusterlintResultsDiagnosticsInner {
    check_name?: string;
    severity?: string;
    message?: string;
    object?: ClusterlintResultsDiagnosticsInnerObject;
}
export interface ClusterlintResultsDiagnosticsInnerObject {
    name?: string;
    kind?: string;
    namespace?: string;
}
export interface ConnectionPool {
    name: string;
    mode: string;
    size: number;
    db: string;
    user?: string;
    connection?: DatabaseClusterConnection;
    private_connection?: DatabaseClusterConnection;
    standby_connection?: DatabaseClusterConnection;
    standby_private_connection?: DatabaseClusterConnection;
}
export interface ConnectionPoolUpdate {
    mode: string;
    size: number;
    db: string;
    user?: string;
}
export interface ConnectionPools {
    pools?: Array<ConnectionPool>;
}
export interface ControlPlaneFirewall {
    enable?: boolean;
    allowed_addresses?: Array<string>;
}
export interface CreateNamespace {
    region: string;
    label: string;
}
export interface CreateTrigger {
    name: string;
    function: string;
    type: string;
    is_enabled: boolean;
    scheduled_details: ScheduledDetails;
}
export interface Credentials {
    server?: string;
    certificate_authority_data?: string;
    client_certificate_data?: string | null;
    client_key_data?: string | null;
    token?: string;
    expires_at?: string;
}
export interface Database {
    name: string;
}
export interface DatabaseBackup {
    database_name: string;
    backup_created_at?: string;
}
export interface DatabaseCluster {
    id?: string;
    name: string;
    engine: DatabaseClusterEngineEnum;
    version?: string;
    semantic_version?: string;
    num_nodes: number;
    size: string;
    region: string;
    status?: DatabaseClusterStatusEnum;
    created_at?: string;
    private_network_uuid?: string;
    tags?: Array<string> | null;
    db_names?: Array<string> | null;
    ui_connection?: DatabaseClusterUiConnection;
    connection?: DatabaseClusterConnection;
    private_connection?: DatabaseClusterConnection;
    standby_connection?: DatabaseClusterConnection;
    standby_private_connection?: DatabaseClusterConnection;
    users?: Array<DatabaseUser> | null;
    maintenance_window?: DatabaseClusterMaintenanceWindow;
    project_id?: string;
    rules?: Array<FirewallRule>;
    version_end_of_life?: string;
    version_end_of_availability?: string;
    storage_size_mib?: number;
    metrics_endpoints?: Array<DatabaseServiceEndpoint>;
}
export declare const DatabaseClusterEngineEnum: {
    readonly Pg: "pg";
    readonly Mysql: "mysql";
    readonly Redis: "redis";
    readonly Mongodb: "mongodb";
    readonly Kafka: "kafka";
    readonly Opensearch: "opensearch";
};
export type DatabaseClusterEngineEnum = (typeof DatabaseClusterEngineEnum)[keyof typeof DatabaseClusterEngineEnum];
export declare const DatabaseClusterStatusEnum: {
    readonly Creating: "creating";
    readonly Online: "online";
    readonly Resizing: "resizing";
    readonly Migrating: "migrating";
    readonly Forking: "forking";
};
export type DatabaseClusterStatusEnum = (typeof DatabaseClusterStatusEnum)[keyof typeof DatabaseClusterStatusEnum];
export interface DatabaseClusterConnection {
    uri?: string;
    database?: string;
    host?: string;
    port?: number;
    user?: string;
    password?: string;
    ssl?: boolean;
}
export interface DatabaseClusterMaintenanceWindow {
    day: string;
    hour: string;
    pending?: boolean;
    description?: Array<string>;
}
export interface DatabaseClusterResize {
    size: string;
    num_nodes: number;
    storage_size_mib?: number;
}
export interface DatabaseClusterUiConnection {
    uri?: string;
    host?: string;
    port?: number;
    user?: string;
    password?: string;
    ssl?: boolean;
}
export interface DatabaseConfig {
    config?: DatabaseConfigConfig;
}
export interface DatabaseConfigConfig {
    backup_hour?: number;
    backup_minute?: number;
    sql_mode?: string;
    connect_timeout?: number;
    default_time_zone?: string;
    group_concat_max_len?: number;
    information_schema_stats_expiry?: number;
    innodb_ft_min_token_size?: number;
    innodb_ft_server_stopword_table?: string;
    innodb_lock_wait_timeout?: number;
    innodb_log_buffer_size?: number;
    innodb_online_alter_log_max_size?: number;
    innodb_print_all_deadlocks?: boolean;
    innodb_rollback_on_timeout?: boolean;
    interactive_timeout?: number;
    internal_tmp_mem_storage_engine?: DatabaseConfigConfigInternalTmpMemStorageEngineEnum;
    net_read_timeout?: number;
    net_write_timeout?: number;
    sql_require_primary_key?: boolean;
    wait_timeout?: number;
    max_allowed_packet?: number;
    max_heap_table_size?: number;
    sort_buffer_size?: number;
    tmp_table_size?: number;
    slow_query_log?: boolean;
    long_query_time?: number;
    binlog_retention_period?: number;
    innodb_change_buffer_max_size?: number;
    innodb_flush_neighbors?: DatabaseConfigConfigInnodbFlushNeighborsEnum;
    innodb_read_io_threads?: number;
    innodb_write_io_threads?: number;
    innodb_thread_concurrency?: number;
    net_buffer_length?: number;
    autovacuum_freeze_max_age?: number;
    autovacuum_max_workers?: number;
    autovacuum_naptime?: number;
    autovacuum_vacuum_threshold?: number;
    autovacuum_analyze_threshold?: number;
    autovacuum_vacuum_scale_factor?: number;
    autovacuum_analyze_scale_factor?: number;
    autovacuum_vacuum_cost_delay?: number;
    autovacuum_vacuum_cost_limit?: number;
    bgwriter_delay?: number;
    bgwriter_flush_after?: number;
    bgwriter_lru_maxpages?: number;
    bgwriter_lru_multiplier?: number;
    deadlock_timeout?: number;
    default_toast_compression?: DatabaseConfigConfigDefaultToastCompressionEnum;
    idle_in_transaction_session_timeout?: number;
    jit?: boolean;
    log_autovacuum_min_duration?: number;
    log_error_verbosity?: DatabaseConfigConfigLogErrorVerbosityEnum;
    log_line_prefix?: DatabaseConfigConfigLogLinePrefixEnum;
    log_min_duration_statement?: number;
    max_files_per_process?: number;
    max_prepared_transactions?: number;
    max_pred_locks_per_transaction?: number;
    max_locks_per_transaction?: number;
    max_stack_depth?: number;
    max_standby_archive_delay?: number;
    max_standby_streaming_delay?: number;
    max_replication_slots?: number;
    max_logical_replication_workers?: number;
    max_parallel_workers?: number;
    max_parallel_workers_per_gather?: number;
    max_worker_processes?: number;
    "pg_partman_bgw.role"?: string;
    "pg_partman_bgw.interval"?: number;
    "pg_stat_statements.track"?: DatabaseConfigConfigPgStatStatementsTrackEnum;
    temp_file_limit?: number;
    timezone?: string;
    track_activity_query_size?: number;
    track_commit_timestamp?: DatabaseConfigConfigTrackCommitTimestampEnum;
    track_functions?: DatabaseConfigConfigTrackFunctionsEnum;
    track_io_timing?: DatabaseConfigConfigTrackIoTimingEnum;
    max_wal_senders?: number;
    wal_sender_timeout?: number;
    wal_writer_delay?: number;
    shared_buffers_percentage?: number;
    pgbouncer?: PgbouncerAdvancedConfig;
    work_mem?: number;
    timescaledb?: TimescaledbAdvancedConfig;
    synchronous_replication?: DatabaseConfigConfigSynchronousReplicationEnum;
    stat_monitor_enable?: boolean;
    redis_maxmemory_policy?: EvictionPolicyModel;
    redis_pubsub_client_output_buffer_limit?: number;
    redis_number_of_databases?: number;
    redis_io_threads?: number;
    redis_lfu_log_factor?: number;
    redis_lfu_decay_time?: number;
    redis_ssl?: boolean;
    redis_timeout?: number;
    redis_notify_keyspace_events?: string;
    redis_persistence?: DatabaseConfigConfigRedisPersistenceEnum;
    redis_acl_channels_default?: DatabaseConfigConfigRedisAclChannelsDefaultEnum;
    default_read_concern?: DatabaseConfigConfigDefaultReadConcernEnum;
    default_write_concern?: string;
    transaction_lifetime_limit_seconds?: number;
    slow_op_threshold_ms?: number;
    verbosity?: number;
    compression_type?: DatabaseConfigConfigCompressionTypeEnum;
    group_initial_rebalance_delay_ms?: number;
    group_min_session_timeout_ms?: number;
    group_max_session_timeout_ms?: number;
    connections_max_idle_ms?: number;
    max_incremental_fetch_session_cache_slots?: number;
    message_max_bytes?: number;
    offsets_retention_minutes?: number;
    log_cleaner_delete_retention_ms?: number;
    log_cleaner_min_cleanable_ratio?: number;
    log_cleaner_max_compaction_lag_ms?: number;
    log_cleaner_min_compaction_lag_ms?: number;
    log_cleanup_policy?: DatabaseConfigConfigLogCleanupPolicyEnum;
    log_flush_interval_messages?: number;
    log_flush_interval_ms?: number;
    log_index_interval_bytes?: number;
    log_index_size_max_bytes?: number;
    log_message_downconversion_enable?: boolean;
    log_message_timestamp_type?: DatabaseConfigConfigLogMessageTimestampTypeEnum;
    log_message_timestamp_difference_max_ms?: number;
    log_preallocate?: boolean;
    log_retention_bytes?: number;
    log_retention_hours?: number;
    log_retention_ms?: number;
    log_roll_jitter_ms?: number;
    log_roll_ms?: number;
    log_segment_bytes?: number;
    log_segment_delete_delay_ms?: number;
    auto_create_topics_enable?: boolean;
    min_insync_replicas?: number;
    num_partitions?: number;
    default_replication_factor?: number;
    replica_fetch_max_bytes?: number;
    replica_fetch_response_max_bytes?: number;
    max_connections_per_ip?: number;
    producer_purgatory_purge_interval_requests?: number;
    socket_request_max_bytes?: number;
    transaction_state_log_segment_bytes?: number;
    transaction_remove_expired_transaction_cleanup_interval_ms?: number;
    http_max_content_length_bytes?: number;
    http_max_header_size_bytes?: number;
    http_max_initial_line_length_bytes?: number;
    indices_query_bool_max_clause_count?: number;
    indices_fielddata_cache_size_percentage?: number;
    indices_memory_index_buffer_size_percentage?: number;
    indices_memory_min_index_buffer_size_mb?: number;
    indices_memory_max_index_buffer_size_mb?: number;
    indices_queries_cache_size_percentage?: number;
    indices_recovery_max_mb_per_sec?: number;
    indices_recovery_max_concurrent_file_chunks?: number;
    thread_pool_search_size?: number;
    thread_pool_search_throttled_size?: number;
    thread_pool_get_size?: number;
    thread_pool_analyze_size?: number;
    thread_pool_write_size?: number;
    thread_pool_force_merge_size?: number;
    thread_pool_search_queue_size?: number;
    thread_pool_search_throttled_queue_size?: number;
    thread_pool_get_queue_size?: number;
    thread_pool_analyze_queue_size?: number;
    thread_pool_write_queue_size?: number;
    ism_enabled?: boolean;
    ism_history_enabled?: boolean;
    ism_history_max_age_hours?: number;
    ism_history_max_docs?: number;
    ism_history_rollover_check_period_hours?: number;
    ism_history_rollover_retention_period_days?: number;
    search_max_buckets?: number;
    action_auto_create_index_enabled?: boolean;
    enable_security_audit?: boolean;
    action_destructive_requires_name?: boolean;
    cluster_max_shards_per_node?: number;
    override_main_response_version?: boolean;
    script_max_compilations_rate?: string;
    cluster_routing_allocation_node_concurrent_recoveries?: number;
    reindex_remote_whitelist?: Array<string>;
}
export declare const DatabaseConfigConfigInternalTmpMemStorageEngineEnum: {
    readonly TempTable: "TempTable";
    readonly Memory: "MEMORY";
};
export type DatabaseConfigConfigInternalTmpMemStorageEngineEnum = (typeof DatabaseConfigConfigInternalTmpMemStorageEngineEnum)[keyof typeof DatabaseConfigConfigInternalTmpMemStorageEngineEnum];
export declare const DatabaseConfigConfigInnodbFlushNeighborsEnum: {
    readonly NUMBER_0: 0;
    readonly NUMBER_1: 1;
    readonly NUMBER_2: 2;
};
export type DatabaseConfigConfigInnodbFlushNeighborsEnum = (typeof DatabaseConfigConfigInnodbFlushNeighborsEnum)[keyof typeof DatabaseConfigConfigInnodbFlushNeighborsEnum];
export declare const DatabaseConfigConfigDefaultToastCompressionEnum: {
    readonly Lz4: "lz4";
    readonly Pglz: "pglz";
};
export type DatabaseConfigConfigDefaultToastCompressionEnum = (typeof DatabaseConfigConfigDefaultToastCompressionEnum)[keyof typeof DatabaseConfigConfigDefaultToastCompressionEnum];
export declare const DatabaseConfigConfigLogErrorVerbosityEnum: {
    readonly Terse: "TERSE";
    readonly Default: "DEFAULT";
    readonly Verbose: "VERBOSE";
};
export type DatabaseConfigConfigLogErrorVerbosityEnum = (typeof DatabaseConfigConfigLogErrorVerbosityEnum)[keyof typeof DatabaseConfigConfigLogErrorVerbosityEnum];
export declare const DatabaseConfigConfigLogLinePrefixEnum: {
    readonly Pidpuserudbdappaclienth: "pid=%p,user=%u,db=%d,app=%a,client=%h";
    readonly MPQUserudbdappa: "%m [%p] %q[user=%u,db=%d,app=%a]";
    readonly TPL1Userudbdappaclienth: "%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h";
};
export type DatabaseConfigConfigLogLinePrefixEnum = (typeof DatabaseConfigConfigLogLinePrefixEnum)[keyof typeof DatabaseConfigConfigLogLinePrefixEnum];
export declare const DatabaseConfigConfigPgStatStatementsTrackEnum: {
    readonly All: "all";
    readonly Top: "top";
    readonly None: "none";
};
export type DatabaseConfigConfigPgStatStatementsTrackEnum = (typeof DatabaseConfigConfigPgStatStatementsTrackEnum)[keyof typeof DatabaseConfigConfigPgStatStatementsTrackEnum];
export declare const DatabaseConfigConfigTrackCommitTimestampEnum: {
    readonly Off: "off";
    readonly On: "on";
};
export type DatabaseConfigConfigTrackCommitTimestampEnum = (typeof DatabaseConfigConfigTrackCommitTimestampEnum)[keyof typeof DatabaseConfigConfigTrackCommitTimestampEnum];
export declare const DatabaseConfigConfigTrackFunctionsEnum: {
    readonly All: "all";
    readonly Pl: "pl";
    readonly None: "none";
};
export type DatabaseConfigConfigTrackFunctionsEnum = (typeof DatabaseConfigConfigTrackFunctionsEnum)[keyof typeof DatabaseConfigConfigTrackFunctionsEnum];
export declare const DatabaseConfigConfigTrackIoTimingEnum: {
    readonly Off: "off";
    readonly On: "on";
};
export type DatabaseConfigConfigTrackIoTimingEnum = (typeof DatabaseConfigConfigTrackIoTimingEnum)[keyof typeof DatabaseConfigConfigTrackIoTimingEnum];
export declare const DatabaseConfigConfigSynchronousReplicationEnum: {
    readonly Off: "off";
    readonly Quorum: "quorum";
};
export type DatabaseConfigConfigSynchronousReplicationEnum = (typeof DatabaseConfigConfigSynchronousReplicationEnum)[keyof typeof DatabaseConfigConfigSynchronousReplicationEnum];
export declare const DatabaseConfigConfigRedisPersistenceEnum: {
    readonly Off: "off";
    readonly Rdb: "rdb";
};
export type DatabaseConfigConfigRedisPersistenceEnum = (typeof DatabaseConfigConfigRedisPersistenceEnum)[keyof typeof DatabaseConfigConfigRedisPersistenceEnum];
export declare const DatabaseConfigConfigRedisAclChannelsDefaultEnum: {
    readonly Allchannels: "allchannels";
    readonly Resetchannels: "resetchannels";
};
export type DatabaseConfigConfigRedisAclChannelsDefaultEnum = (typeof DatabaseConfigConfigRedisAclChannelsDefaultEnum)[keyof typeof DatabaseConfigConfigRedisAclChannelsDefaultEnum];
export declare const DatabaseConfigConfigDefaultReadConcernEnum: {
    readonly Local: "local";
    readonly Available: "available";
    readonly Majority: "majority";
};
export type DatabaseConfigConfigDefaultReadConcernEnum = (typeof DatabaseConfigConfigDefaultReadConcernEnum)[keyof typeof DatabaseConfigConfigDefaultReadConcernEnum];
export declare const DatabaseConfigConfigCompressionTypeEnum: {
    readonly Gzip: "gzip";
    readonly Snappy: "snappy";
    readonly Lz4: "lz4";
    readonly Zstd: "zstd";
    readonly Uncompressed: "uncompressed";
    readonly Producer: "producer";
};
export type DatabaseConfigConfigCompressionTypeEnum = (typeof DatabaseConfigConfigCompressionTypeEnum)[keyof typeof DatabaseConfigConfigCompressionTypeEnum];
export declare const DatabaseConfigConfigLogCleanupPolicyEnum: {
    readonly Delete: "delete";
    readonly Compact: "compact";
    readonly Compactdelete: "compact,delete";
};
export type DatabaseConfigConfigLogCleanupPolicyEnum = (typeof DatabaseConfigConfigLogCleanupPolicyEnum)[keyof typeof DatabaseConfigConfigLogCleanupPolicyEnum];
export declare const DatabaseConfigConfigLogMessageTimestampTypeEnum: {
    readonly CreateTime: "CreateTime";
    readonly LogAppendTime: "LogAppendTime";
};
export type DatabaseConfigConfigLogMessageTimestampTypeEnum = (typeof DatabaseConfigConfigLogMessageTimestampTypeEnum)[keyof typeof DatabaseConfigConfigLogMessageTimestampTypeEnum];
export interface DatabaseConnection {
    uri?: string;
    database?: string;
    host?: string;
    port?: number;
    user?: string;
    password?: string;
    ssl?: boolean;
}
export interface DatabaseLayoutOption {
    num_nodes?: number;
    sizes?: Array<string>;
}
export interface DatabaseLayoutOptions {
    layouts?: Array<DatabaseLayoutOption>;
}
export interface DatabaseMaintenanceWindow {
    day: string;
    hour: string;
    pending?: boolean;
    description?: Array<string>;
}
export interface DatabaseMetricsCredentials {
    credentials?: DatabasesBasicAuthCredentials;
}
export interface DatabaseRegionOptions {
    regions?: Array<string>;
}
export interface DatabaseReplica {
    id?: string;
    name: string;
    region?: string;
    size?: string;
    status?: DatabaseReplicaStatusEnum;
    tags?: Array<string>;
    created_at?: string;
    private_network_uuid?: string;
    connection?: DatabaseReplicaConnection;
    private_connection?: DatabaseReplicaConnection;
    storage_size_mib?: number;
}
export declare const DatabaseReplicaStatusEnum: {
    readonly Creating: "creating";
    readonly Online: "online";
    readonly Resizing: "resizing";
    readonly Migrating: "migrating";
    readonly Forking: "forking";
};
export type DatabaseReplicaStatusEnum = (typeof DatabaseReplicaStatusEnum)[keyof typeof DatabaseReplicaStatusEnum];
export interface DatabaseReplicaConnection {
    uri?: string;
    database?: string;
    host?: string;
    port?: number;
    user?: string;
    password?: string;
    ssl?: boolean;
}
export interface DatabaseServiceEndpoint {
    host?: string;
    port?: number;
}
export interface DatabaseUser {
    name: string;
    role?: DatabaseUserRoleEnum;
    password?: string;
    access_cert?: string;
    access_key?: string;
    mysql_settings?: MysqlSettings;
    settings?: UserSettings;
}
export declare const DatabaseUserRoleEnum: {
    readonly Primary: "primary";
    readonly Normal: "normal";
};
export type DatabaseUserRoleEnum = (typeof DatabaseUserRoleEnum)[keyof typeof DatabaseUserRoleEnum];
export interface DatabaseVersionAvailability {
    end_of_life?: string | null;
    end_of_availability?: string | null;
    version?: string;
}
export interface DatabaseVersionOptions {
    versions?: Array<string>;
}
export interface DatabasesAdd201Response {
    db: Database;
}
export interface DatabasesAddConnectionPool201Response {
    pool: ConnectionPool;
}
export interface DatabasesAddUser201Response {
    user: DatabaseUser;
}
export interface DatabasesAddUserRequest {
    name: string;
    role?: DatabasesAddUserRequestRoleEnum;
    password?: string;
    access_cert?: string;
    access_key?: string;
    mysql_settings?: MysqlSettings;
    settings?: UserSettings;
    readonly?: boolean;
}
export declare const DatabasesAddUserRequestRoleEnum: {
    readonly Primary: "primary";
    readonly Normal: "normal";
};
export type DatabasesAddUserRequestRoleEnum = (typeof DatabasesAddUserRequestRoleEnum)[keyof typeof DatabasesAddUserRequestRoleEnum];
export interface DatabasesBasicAuthCredentials {
    basic_auth_username?: string;
    basic_auth_password?: string;
}
export interface DatabasesCreateCluster201Response {
    database: DatabaseCluster;
}
export interface DatabasesCreateClusterRequest {
    id?: string;
    name: string;
    engine: DatabasesCreateClusterRequestEngineEnum;
    version?: string;
    semantic_version?: string;
    num_nodes: number;
    size: string;
    region: string;
    status?: DatabasesCreateClusterRequestStatusEnum;
    created_at?: string;
    private_network_uuid?: string;
    tags?: Array<string> | null;
    db_names?: Array<string> | null;
    ui_connection?: DatabaseClusterUiConnection;
    connection?: DatabaseClusterConnection;
    private_connection?: DatabaseClusterConnection;
    standby_connection?: DatabaseClusterConnection;
    standby_private_connection?: DatabaseClusterConnection;
    users?: Array<DatabaseUser> | null;
    maintenance_window?: DatabaseClusterMaintenanceWindow;
    project_id?: string;
    rules?: Array<FirewallRule>;
    version_end_of_life?: string;
    version_end_of_availability?: string;
    storage_size_mib?: number;
    metrics_endpoints?: Array<DatabaseServiceEndpoint>;
    backup_restore?: DatabaseBackup;
}
export declare const DatabasesCreateClusterRequestEngineEnum: {
    readonly Pg: "pg";
    readonly Mysql: "mysql";
    readonly Redis: "redis";
    readonly Mongodb: "mongodb";
    readonly Kafka: "kafka";
    readonly Opensearch: "opensearch";
};
export type DatabasesCreateClusterRequestEngineEnum = (typeof DatabasesCreateClusterRequestEngineEnum)[keyof typeof DatabasesCreateClusterRequestEngineEnum];
export declare const DatabasesCreateClusterRequestStatusEnum: {
    readonly Creating: "creating";
    readonly Online: "online";
    readonly Resizing: "resizing";
    readonly Migrating: "migrating";
    readonly Forking: "forking";
};
export type DatabasesCreateClusterRequestStatusEnum = (typeof DatabasesCreateClusterRequestStatusEnum)[keyof typeof DatabasesCreateClusterRequestStatusEnum];
export interface DatabasesCreateKafkaTopic201Response {
    topic?: KafkaTopicVerbose;
}
export interface DatabasesCreateLogsink201Response {
    sink?: LogsinkVerbose;
}
export interface DatabasesCreateReplica201Response {
    replica?: DatabaseReplica;
}
export interface DatabasesGetCa200Response {
    ca: Ca;
}
export interface DatabasesGetClusterMetricsCredentials200Response {
    credentials?: DatabaseMetricsCredentials;
}
export interface DatabasesGetConfig200Response {
    config: DatabasesGetConfig200ResponseConfig;
}
export interface DatabasesGetConfig200ResponseConfig {
    backup_hour?: number;
    backup_minute?: number;
    sql_mode?: string;
    connect_timeout?: number;
    default_time_zone?: string;
    group_concat_max_len?: number;
    information_schema_stats_expiry?: number;
    innodb_ft_min_token_size?: number;
    innodb_ft_server_stopword_table?: string;
    innodb_lock_wait_timeout?: number;
    innodb_log_buffer_size?: number;
    innodb_online_alter_log_max_size?: number;
    innodb_print_all_deadlocks?: boolean;
    innodb_rollback_on_timeout?: boolean;
    interactive_timeout?: number;
    internal_tmp_mem_storage_engine?: DatabasesGetConfig200ResponseConfigInternalTmpMemStorageEngineEnum;
    net_read_timeout?: number;
    net_write_timeout?: number;
    sql_require_primary_key?: boolean;
    wait_timeout?: number;
    max_allowed_packet?: number;
    max_heap_table_size?: number;
    sort_buffer_size?: number;
    tmp_table_size?: number;
    slow_query_log?: boolean;
    long_query_time?: number;
    binlog_retention_period?: number;
    innodb_change_buffer_max_size?: number;
    innodb_flush_neighbors?: DatabasesGetConfig200ResponseConfigInnodbFlushNeighborsEnum;
    innodb_read_io_threads?: number;
    innodb_write_io_threads?: number;
    innodb_thread_concurrency?: number;
    net_buffer_length?: number;
    autovacuum_freeze_max_age?: number;
    autovacuum_max_workers?: number;
    autovacuum_naptime?: number;
    autovacuum_vacuum_threshold?: number;
    autovacuum_analyze_threshold?: number;
    autovacuum_vacuum_scale_factor?: number;
    autovacuum_analyze_scale_factor?: number;
    autovacuum_vacuum_cost_delay?: number;
    autovacuum_vacuum_cost_limit?: number;
    bgwriter_delay?: number;
    bgwriter_flush_after?: number;
    bgwriter_lru_maxpages?: number;
    bgwriter_lru_multiplier?: number;
    deadlock_timeout?: number;
    default_toast_compression?: DatabasesGetConfig200ResponseConfigDefaultToastCompressionEnum;
    idle_in_transaction_session_timeout?: number;
    jit?: boolean;
    log_autovacuum_min_duration?: number;
    log_error_verbosity?: DatabasesGetConfig200ResponseConfigLogErrorVerbosityEnum;
    log_line_prefix?: DatabasesGetConfig200ResponseConfigLogLinePrefixEnum;
    log_min_duration_statement?: number;
    max_files_per_process?: number;
    max_prepared_transactions?: number;
    max_pred_locks_per_transaction?: number;
    max_locks_per_transaction?: number;
    max_stack_depth?: number;
    max_standby_archive_delay?: number;
    max_standby_streaming_delay?: number;
    max_replication_slots?: number;
    max_logical_replication_workers?: number;
    max_parallel_workers?: number;
    max_parallel_workers_per_gather?: number;
    max_worker_processes?: number;
    "pg_partman_bgw.role"?: string;
    "pg_partman_bgw.interval"?: number;
    "pg_stat_statements.track"?: DatabasesGetConfig200ResponseConfigPgStatStatementsTrackEnum;
    temp_file_limit?: number;
    timezone?: string;
    track_activity_query_size?: number;
    track_commit_timestamp?: DatabasesGetConfig200ResponseConfigTrackCommitTimestampEnum;
    track_functions?: DatabasesGetConfig200ResponseConfigTrackFunctionsEnum;
    track_io_timing?: DatabasesGetConfig200ResponseConfigTrackIoTimingEnum;
    max_wal_senders?: number;
    wal_sender_timeout?: number;
    wal_writer_delay?: number;
    shared_buffers_percentage?: number;
    pgbouncer?: PgbouncerAdvancedConfig;
    work_mem?: number;
    timescaledb?: TimescaledbAdvancedConfig;
    synchronous_replication?: DatabasesGetConfig200ResponseConfigSynchronousReplicationEnum;
    stat_monitor_enable?: boolean;
    redis_maxmemory_policy?: EvictionPolicyModel;
    redis_pubsub_client_output_buffer_limit?: number;
    redis_number_of_databases?: number;
    redis_io_threads?: number;
    redis_lfu_log_factor?: number;
    redis_lfu_decay_time?: number;
    redis_ssl?: boolean;
    redis_timeout?: number;
    redis_notify_keyspace_events?: string;
    redis_persistence?: DatabasesGetConfig200ResponseConfigRedisPersistenceEnum;
    redis_acl_channels_default?: DatabasesGetConfig200ResponseConfigRedisAclChannelsDefaultEnum;
    compression_type?: DatabasesGetConfig200ResponseConfigCompressionTypeEnum;
    group_initial_rebalance_delay_ms?: number;
    group_min_session_timeout_ms?: number;
    group_max_session_timeout_ms?: number;
    connections_max_idle_ms?: number;
    max_incremental_fetch_session_cache_slots?: number;
    message_max_bytes?: number;
    offsets_retention_minutes?: number;
    log_cleaner_delete_retention_ms?: number;
    log_cleaner_min_cleanable_ratio?: number;
    log_cleaner_max_compaction_lag_ms?: number;
    log_cleaner_min_compaction_lag_ms?: number;
    log_cleanup_policy?: DatabasesGetConfig200ResponseConfigLogCleanupPolicyEnum;
    log_flush_interval_messages?: number;
    log_flush_interval_ms?: number;
    log_index_interval_bytes?: number;
    log_index_size_max_bytes?: number;
    log_message_downconversion_enable?: boolean;
    log_message_timestamp_type?: DatabasesGetConfig200ResponseConfigLogMessageTimestampTypeEnum;
    log_message_timestamp_difference_max_ms?: number;
    log_preallocate?: boolean;
    log_retention_bytes?: number;
    log_retention_hours?: number;
    log_retention_ms?: number;
    log_roll_jitter_ms?: number;
    log_roll_ms?: number;
    log_segment_bytes?: number;
    log_segment_delete_delay_ms?: number;
    auto_create_topics_enable?: boolean;
    min_insync_replicas?: number;
    num_partitions?: number;
    default_replication_factor?: number;
    replica_fetch_max_bytes?: number;
    replica_fetch_response_max_bytes?: number;
    max_connections_per_ip?: number;
    producer_purgatory_purge_interval_requests?: number;
    socket_request_max_bytes?: number;
    transaction_state_log_segment_bytes?: number;
    transaction_remove_expired_transaction_cleanup_interval_ms?: number;
    http_max_content_length_bytes?: number;
    http_max_header_size_bytes?: number;
    http_max_initial_line_length_bytes?: number;
    indices_query_bool_max_clause_count?: number;
    indices_fielddata_cache_size_percentage?: number;
    indices_memory_index_buffer_size_percentage?: number;
    indices_memory_min_index_buffer_size_mb?: number;
    indices_memory_max_index_buffer_size_mb?: number;
    indices_queries_cache_size_percentage?: number;
    indices_recovery_max_mb_per_sec?: number;
    indices_recovery_max_concurrent_file_chunks?: number;
    thread_pool_search_size?: number;
    thread_pool_search_throttled_size?: number;
    thread_pool_get_size?: number;
    thread_pool_analyze_size?: number;
    thread_pool_write_size?: number;
    thread_pool_force_merge_size?: number;
    thread_pool_search_queue_size?: number;
    thread_pool_search_throttled_queue_size?: number;
    thread_pool_get_queue_size?: number;
    thread_pool_analyze_queue_size?: number;
    thread_pool_write_queue_size?: number;
    ism_enabled?: boolean;
    ism_history_enabled?: boolean;
    ism_history_max_age_hours?: number;
    ism_history_max_docs?: number;
    ism_history_rollover_check_period_hours?: number;
    ism_history_rollover_retention_period_days?: number;
    search_max_buckets?: number;
    action_auto_create_index_enabled?: boolean;
    enable_security_audit?: boolean;
    action_destructive_requires_name?: boolean;
    cluster_max_shards_per_node?: number;
    override_main_response_version?: boolean;
    script_max_compilations_rate?: string;
    cluster_routing_allocation_node_concurrent_recoveries?: number;
    reindex_remote_whitelist?: Array<string>;
    default_read_concern?: DatabasesGetConfig200ResponseConfigDefaultReadConcernEnum;
    default_write_concern?: string;
    transaction_lifetime_limit_seconds?: number;
    slow_op_threshold_ms?: number;
    verbosity?: number;
}
export declare const DatabasesGetConfig200ResponseConfigInternalTmpMemStorageEngineEnum: {
    readonly TempTable: "TempTable";
    readonly Memory: "MEMORY";
};
export type DatabasesGetConfig200ResponseConfigInternalTmpMemStorageEngineEnum = (typeof DatabasesGetConfig200ResponseConfigInternalTmpMemStorageEngineEnum)[keyof typeof DatabasesGetConfig200ResponseConfigInternalTmpMemStorageEngineEnum];
export declare const DatabasesGetConfig200ResponseConfigInnodbFlushNeighborsEnum: {
    readonly NUMBER_0: 0;
    readonly NUMBER_1: 1;
    readonly NUMBER_2: 2;
};
export type DatabasesGetConfig200ResponseConfigInnodbFlushNeighborsEnum = (typeof DatabasesGetConfig200ResponseConfigInnodbFlushNeighborsEnum)[keyof typeof DatabasesGetConfig200ResponseConfigInnodbFlushNeighborsEnum];
export declare const DatabasesGetConfig200ResponseConfigDefaultToastCompressionEnum: {
    readonly Lz4: "lz4";
    readonly Pglz: "pglz";
};
export type DatabasesGetConfig200ResponseConfigDefaultToastCompressionEnum = (typeof DatabasesGetConfig200ResponseConfigDefaultToastCompressionEnum)[keyof typeof DatabasesGetConfig200ResponseConfigDefaultToastCompressionEnum];
export declare const DatabasesGetConfig200ResponseConfigLogErrorVerbosityEnum: {
    readonly Terse: "TERSE";
    readonly Default: "DEFAULT";
    readonly Verbose: "VERBOSE";
};
export type DatabasesGetConfig200ResponseConfigLogErrorVerbosityEnum = (typeof DatabasesGetConfig200ResponseConfigLogErrorVerbosityEnum)[keyof typeof DatabasesGetConfig200ResponseConfigLogErrorVerbosityEnum];
export declare const DatabasesGetConfig200ResponseConfigLogLinePrefixEnum: {
    readonly Pidpuserudbdappaclienth: "pid=%p,user=%u,db=%d,app=%a,client=%h";
    readonly MPQUserudbdappa: "%m [%p] %q[user=%u,db=%d,app=%a]";
    readonly TPL1Userudbdappaclienth: "%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h";
};
export type DatabasesGetConfig200ResponseConfigLogLinePrefixEnum = (typeof DatabasesGetConfig200ResponseConfigLogLinePrefixEnum)[keyof typeof DatabasesGetConfig200ResponseConfigLogLinePrefixEnum];
export declare const DatabasesGetConfig200ResponseConfigPgStatStatementsTrackEnum: {
    readonly All: "all";
    readonly Top: "top";
    readonly None: "none";
};
export type DatabasesGetConfig200ResponseConfigPgStatStatementsTrackEnum = (typeof DatabasesGetConfig200ResponseConfigPgStatStatementsTrackEnum)[keyof typeof DatabasesGetConfig200ResponseConfigPgStatStatementsTrackEnum];
export declare const DatabasesGetConfig200ResponseConfigTrackCommitTimestampEnum: {
    readonly Off: "off";
    readonly On: "on";
};
export type DatabasesGetConfig200ResponseConfigTrackCommitTimestampEnum = (typeof DatabasesGetConfig200ResponseConfigTrackCommitTimestampEnum)[keyof typeof DatabasesGetConfig200ResponseConfigTrackCommitTimestampEnum];
export declare const DatabasesGetConfig200ResponseConfigTrackFunctionsEnum: {
    readonly All: "all";
    readonly Pl: "pl";
    readonly None: "none";
};
export type DatabasesGetConfig200ResponseConfigTrackFunctionsEnum = (typeof DatabasesGetConfig200ResponseConfigTrackFunctionsEnum)[keyof typeof DatabasesGetConfig200ResponseConfigTrackFunctionsEnum];
export declare const DatabasesGetConfig200ResponseConfigTrackIoTimingEnum: {
    readonly Off: "off";
    readonly On: "on";
};
export type DatabasesGetConfig200ResponseConfigTrackIoTimingEnum = (typeof DatabasesGetConfig200ResponseConfigTrackIoTimingEnum)[keyof typeof DatabasesGetConfig200ResponseConfigTrackIoTimingEnum];
export declare const DatabasesGetConfig200ResponseConfigSynchronousReplicationEnum: {
    readonly Off: "off";
    readonly Quorum: "quorum";
};
export type DatabasesGetConfig200ResponseConfigSynchronousReplicationEnum = (typeof DatabasesGetConfig200ResponseConfigSynchronousReplicationEnum)[keyof typeof DatabasesGetConfig200ResponseConfigSynchronousReplicationEnum];
export declare const DatabasesGetConfig200ResponseConfigRedisPersistenceEnum: {
    readonly Off: "off";
    readonly Rdb: "rdb";
};
export type DatabasesGetConfig200ResponseConfigRedisPersistenceEnum = (typeof DatabasesGetConfig200ResponseConfigRedisPersistenceEnum)[keyof typeof DatabasesGetConfig200ResponseConfigRedisPersistenceEnum];
export declare const DatabasesGetConfig200ResponseConfigRedisAclChannelsDefaultEnum: {
    readonly Allchannels: "allchannels";
    readonly Resetchannels: "resetchannels";
};
export type DatabasesGetConfig200ResponseConfigRedisAclChannelsDefaultEnum = (typeof DatabasesGetConfig200ResponseConfigRedisAclChannelsDefaultEnum)[keyof typeof DatabasesGetConfig200ResponseConfigRedisAclChannelsDefaultEnum];
export declare const DatabasesGetConfig200ResponseConfigCompressionTypeEnum: {
    readonly Gzip: "gzip";
    readonly Snappy: "snappy";
    readonly Lz4: "lz4";
    readonly Zstd: "zstd";
    readonly Uncompressed: "uncompressed";
    readonly Producer: "producer";
};
export type DatabasesGetConfig200ResponseConfigCompressionTypeEnum = (typeof DatabasesGetConfig200ResponseConfigCompressionTypeEnum)[keyof typeof DatabasesGetConfig200ResponseConfigCompressionTypeEnum];
export declare const DatabasesGetConfig200ResponseConfigLogCleanupPolicyEnum: {
    readonly Delete: "delete";
    readonly Compact: "compact";
    readonly Compactdelete: "compact,delete";
};
export type DatabasesGetConfig200ResponseConfigLogCleanupPolicyEnum = (typeof DatabasesGetConfig200ResponseConfigLogCleanupPolicyEnum)[keyof typeof DatabasesGetConfig200ResponseConfigLogCleanupPolicyEnum];
export declare const DatabasesGetConfig200ResponseConfigLogMessageTimestampTypeEnum: {
    readonly CreateTime: "CreateTime";
    readonly LogAppendTime: "LogAppendTime";
};
export type DatabasesGetConfig200ResponseConfigLogMessageTimestampTypeEnum = (typeof DatabasesGetConfig200ResponseConfigLogMessageTimestampTypeEnum)[keyof typeof DatabasesGetConfig200ResponseConfigLogMessageTimestampTypeEnum];
export declare const DatabasesGetConfig200ResponseConfigDefaultReadConcernEnum: {
    readonly Local: "local";
    readonly Available: "available";
    readonly Majority: "majority";
};
export type DatabasesGetConfig200ResponseConfigDefaultReadConcernEnum = (typeof DatabasesGetConfig200ResponseConfigDefaultReadConcernEnum)[keyof typeof DatabasesGetConfig200ResponseConfigDefaultReadConcernEnum];
export interface DatabasesGetEvictionPolicy200Response {
    eviction_policy: EvictionPolicyModel;
}
export interface DatabasesList200Response {
    dbs?: Array<Database>;
}
export interface DatabasesListBackups200Response {
    backups: Array<Backup>;
}
export interface DatabasesListClusters200Response {
    databases?: Array<DatabaseCluster>;
}
export interface DatabasesListEventsLogs200Response {
    events?: Array<EventsLogs>;
}
export interface DatabasesListFirewallRules200Response {
    rules?: Array<FirewallRule>;
}
export interface DatabasesListKafkaTopics200Response {
    topics?: Array<KafkaTopic>;
}
export interface DatabasesListLogsink201Response {
    sinks?: Array<LogsinkVerbose>;
}
export interface DatabasesListOpeasearchIndexes200Response {
    indexes?: Array<OpensearchIndex>;
}
export interface DatabasesListReplicas200Response {
    replicas?: Array<DatabaseReplica>;
}
export interface DatabasesListUsers200Response {
    users?: Array<DatabaseUser>;
}
export interface DatabasesResetAuthRequest {
    mysql_settings?: MysqlSettings;
}
export interface DatabasesUpdateEvictionPolicyRequest {
    eviction_policy: EvictionPolicyModel;
}
export interface DatabasesUpdateFirewallRulesRequest {
    rules?: Array<FirewallRule>;
}
export interface DatabasesUpdateRegionRequest {
    region: string;
}
export interface DatabasesUpdateUserRequest {
    settings: UserSettings;
}
export interface DestroyAssociatedKubernetesResources {
    load_balancers?: Array<string>;
    volumes?: Array<string>;
    volume_snapshots?: Array<string>;
}
export interface DestroyedAssociatedResource {
    id?: string;
    name?: string;
    destroyed_at?: string;
    error_message?: string;
}
export declare const Distribution: {
    readonly ArchLinux: "Arch Linux";
    readonly CentOs: "CentOS";
    readonly CoreOs: "CoreOS";
    readonly Debian: "Debian";
    readonly Fedora: "Fedora";
    readonly FedoraAtomic: "Fedora Atomic";
    readonly FreeBsd: "FreeBSD";
    readonly Gentoo: "Gentoo";
    readonly OpenSuse: "openSUSE";
    readonly RancherOs: "RancherOS";
    readonly RockyLinux: "Rocky Linux";
    readonly Ubuntu: "Ubuntu";
    readonly Unknown: "Unknown";
};
export type Distribution = (typeof Distribution)[keyof typeof Distribution];
export interface DockerCredentials {
    auths?: DockerCredentialsAuths;
}
export interface DockerCredentialsAuths {
    "registry.digitalocean.com"?: DockerCredentialsAuthsRegistryDigitaloceanCom;
}
export interface DockerCredentialsAuthsRegistryDigitaloceanCom {
    auth?: string;
}
export interface Domain {
    name?: string;
    ip_address?: string;
    ttl?: number | null;
    zone_file?: string | null;
}
export interface DomainRecord {
    id?: number;
    type: string;
    name?: string;
    data?: string;
    priority?: number | null;
    port?: number | null;
    ttl?: number;
    weight?: number | null;
    flags?: number | null;
    tag?: string | null;
}
export interface DomainRecordA {
    id?: number;
    type: string;
    name: string;
    data: string;
    priority?: number | null;
    port?: number | null;
    ttl?: number;
    weight?: number | null;
    flags?: number | null;
    tag?: string | null;
}
export interface DomainRecordAaaa {
    id?: number;
    type: string;
    name: string;
    data: string;
    priority?: number | null;
    port?: number | null;
    ttl?: number;
    weight?: number | null;
    flags?: number | null;
    tag?: string | null;
}
export interface DomainRecordCaa {
    id?: number;
    type: string;
    name: string;
    data: string;
    priority?: number | null;
    port?: number | null;
    ttl?: number;
    weight?: number | null;
    flags: number | null;
    tag: string | null;
}
export interface DomainRecordCname {
    id?: number;
    type: string;
    name: string;
    data: string;
    priority?: number | null;
    port?: number | null;
    ttl?: number;
    weight?: number | null;
    flags?: number | null;
    tag?: string | null;
}
export interface DomainRecordMx {
    id?: number;
    type: string;
    name?: string;
    data: string;
    priority: number | null;
    port?: number | null;
    ttl?: number;
    weight?: number | null;
    flags?: number | null;
    tag?: string | null;
}
export interface DomainRecordNs {
    id?: number;
    type: string;
    name: string;
    data: string;
    priority?: number | null;
    port?: number | null;
    ttl?: number;
    weight?: number | null;
    flags: number | null;
    tag: string | null;
}
export interface DomainRecordSoa {
    id?: number;
    type: string;
    name?: string;
    data?: string;
    priority?: number | null;
    port?: number | null;
    ttl: number;
    weight?: number | null;
    flags?: number | null;
    tag?: string | null;
}
export interface DomainRecordSrv {
    id?: number;
    type: string;
    name: string;
    data: string;
    priority: number | null;
    port: number | null;
    ttl?: number;
    weight?: number | null;
    flags: number | null;
    tag: string | null;
}
export interface DomainRecordTxt {
    id?: number;
    type: string;
    name: string;
    data: string;
    priority?: number | null;
    port?: number | null;
    ttl?: number;
    weight?: number | null;
    flags: number | null;
    tag: string | null;
}
export interface DomainsCreate201Response {
    domain?: Domain;
}
export interface DomainsCreateRecord201Response {
    domain_record?: DomainRecord;
}
export interface DomainsCreateRecordRequest {
    id?: number;
    type: string;
    name: string;
    data: string;
    priority: number | null;
    port: number | null;
    ttl: number;
    weight?: number | null;
    flags: number | null;
    tag: string | null;
}
export interface DomainsGet200Response {
    domain?: Domain;
}
export interface DomainsGetRecord200Response {
    domain_record?: DomainRecord;
}
export interface DomainsList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    domains: Array<Domain>;
}
export interface DomainsListRecords200Response {
    links?: PageLinks;
    meta: MetaMeta;
    domain_records?: Array<DomainRecord>;
}
export interface Droplet {
    id: number;
    name: string;
    memory: number;
    vcpus: number;
    disk: number;
    locked: boolean;
    status: DropletStatusEnum;
    kernel?: Kernel | null;
    created_at: string;
    features: Array<string>;
    backup_ids: Array<number>;
    next_backup_window: DropletNextBackupWindow | null;
    snapshot_ids: Array<number>;
    image: Image;
    volume_ids: Array<string>;
    size: Size;
    size_slug: string;
    networks: DropletNetworks;
    region: Region;
    tags: Array<string>;
    vpc_uuid?: string;
}
export declare const DropletStatusEnum: {
    readonly New: "new";
    readonly Active: "active";
    readonly Off: "off";
    readonly Archive: "archive";
};
export type DropletStatusEnum = (typeof DropletStatusEnum)[keyof typeof DropletStatusEnum];
export interface DropletAction {
    type: DropletActionTypeEnum;
}
export declare const DropletActionTypeEnum: {
    readonly EnableBackups: "enable_backups";
    readonly DisableBackups: "disable_backups";
    readonly Reboot: "reboot";
    readonly PowerCycle: "power_cycle";
    readonly Shutdown: "shutdown";
    readonly PowerOff: "power_off";
    readonly PowerOn: "power_on";
    readonly Restore: "restore";
    readonly PasswordReset: "password_reset";
    readonly Resize: "resize";
    readonly Rebuild: "rebuild";
    readonly Rename: "rename";
    readonly ChangeKernel: "change_kernel";
    readonly EnableIpv6: "enable_ipv6";
    readonly Snapshot: "snapshot";
};
export type DropletActionTypeEnum = (typeof DropletActionTypeEnum)[keyof typeof DropletActionTypeEnum];
export interface DropletActionChangeKernel {
    type: DropletActionChangeKernelTypeEnum;
    kernel?: number;
}
export declare const DropletActionChangeKernelTypeEnum: {
    readonly EnableBackups: "enable_backups";
    readonly DisableBackups: "disable_backups";
    readonly Reboot: "reboot";
    readonly PowerCycle: "power_cycle";
    readonly Shutdown: "shutdown";
    readonly PowerOff: "power_off";
    readonly PowerOn: "power_on";
    readonly Restore: "restore";
    readonly PasswordReset: "password_reset";
    readonly Resize: "resize";
    readonly Rebuild: "rebuild";
    readonly Rename: "rename";
    readonly ChangeKernel: "change_kernel";
    readonly EnableIpv6: "enable_ipv6";
    readonly Snapshot: "snapshot";
};
export type DropletActionChangeKernelTypeEnum = (typeof DropletActionChangeKernelTypeEnum)[keyof typeof DropletActionChangeKernelTypeEnum];
export interface DropletActionRebuild {
    type: DropletActionRebuildTypeEnum;
    image?: DropletActionRebuildAllOfImage;
}
export declare const DropletActionRebuildTypeEnum: {
    readonly EnableBackups: "enable_backups";
    readonly DisableBackups: "disable_backups";
    readonly Reboot: "reboot";
    readonly PowerCycle: "power_cycle";
    readonly Shutdown: "shutdown";
    readonly PowerOff: "power_off";
    readonly PowerOn: "power_on";
    readonly Restore: "restore";
    readonly PasswordReset: "password_reset";
    readonly Resize: "resize";
    readonly Rebuild: "rebuild";
    readonly Rename: "rename";
    readonly ChangeKernel: "change_kernel";
    readonly EnableIpv6: "enable_ipv6";
    readonly Snapshot: "snapshot";
};
export type DropletActionRebuildTypeEnum = (typeof DropletActionRebuildTypeEnum)[keyof typeof DropletActionRebuildTypeEnum];
export type DropletActionRebuildAllOfImage = number | string;
export interface DropletActionRename {
    type: DropletActionRenameTypeEnum;
    name?: string;
}
export declare const DropletActionRenameTypeEnum: {
    readonly EnableBackups: "enable_backups";
    readonly DisableBackups: "disable_backups";
    readonly Reboot: "reboot";
    readonly PowerCycle: "power_cycle";
    readonly Shutdown: "shutdown";
    readonly PowerOff: "power_off";
    readonly PowerOn: "power_on";
    readonly Restore: "restore";
    readonly PasswordReset: "password_reset";
    readonly Resize: "resize";
    readonly Rebuild: "rebuild";
    readonly Rename: "rename";
    readonly ChangeKernel: "change_kernel";
    readonly EnableIpv6: "enable_ipv6";
    readonly Snapshot: "snapshot";
};
export type DropletActionRenameTypeEnum = (typeof DropletActionRenameTypeEnum)[keyof typeof DropletActionRenameTypeEnum];
export interface DropletActionResize {
    type: DropletActionResizeTypeEnum;
    disk?: boolean;
    size?: string;
}
export declare const DropletActionResizeTypeEnum: {
    readonly EnableBackups: "enable_backups";
    readonly DisableBackups: "disable_backups";
    readonly Reboot: "reboot";
    readonly PowerCycle: "power_cycle";
    readonly Shutdown: "shutdown";
    readonly PowerOff: "power_off";
    readonly PowerOn: "power_on";
    readonly Restore: "restore";
    readonly PasswordReset: "password_reset";
    readonly Resize: "resize";
    readonly Rebuild: "rebuild";
    readonly Rename: "rename";
    readonly ChangeKernel: "change_kernel";
    readonly EnableIpv6: "enable_ipv6";
    readonly Snapshot: "snapshot";
};
export type DropletActionResizeTypeEnum = (typeof DropletActionResizeTypeEnum)[keyof typeof DropletActionResizeTypeEnum];
export interface DropletActionRestore {
    type: DropletActionRestoreTypeEnum;
    image?: number;
}
export declare const DropletActionRestoreTypeEnum: {
    readonly EnableBackups: "enable_backups";
    readonly DisableBackups: "disable_backups";
    readonly Reboot: "reboot";
    readonly PowerCycle: "power_cycle";
    readonly Shutdown: "shutdown";
    readonly PowerOff: "power_off";
    readonly PowerOn: "power_on";
    readonly Restore: "restore";
    readonly PasswordReset: "password_reset";
    readonly Resize: "resize";
    readonly Rebuild: "rebuild";
    readonly Rename: "rename";
    readonly ChangeKernel: "change_kernel";
    readonly EnableIpv6: "enable_ipv6";
    readonly Snapshot: "snapshot";
};
export type DropletActionRestoreTypeEnum = (typeof DropletActionRestoreTypeEnum)[keyof typeof DropletActionRestoreTypeEnum];
export interface DropletActionSnapshot {
    type: DropletActionSnapshotTypeEnum;
    name?: string;
}
export declare const DropletActionSnapshotTypeEnum: {
    readonly EnableBackups: "enable_backups";
    readonly DisableBackups: "disable_backups";
    readonly Reboot: "reboot";
    readonly PowerCycle: "power_cycle";
    readonly Shutdown: "shutdown";
    readonly PowerOff: "power_off";
    readonly PowerOn: "power_on";
    readonly Restore: "restore";
    readonly PasswordReset: "password_reset";
    readonly Resize: "resize";
    readonly Rebuild: "rebuild";
    readonly Rename: "rename";
    readonly ChangeKernel: "change_kernel";
    readonly EnableIpv6: "enable_ipv6";
    readonly Snapshot: "snapshot";
};
export type DropletActionSnapshotTypeEnum = (typeof DropletActionSnapshotTypeEnum)[keyof typeof DropletActionSnapshotTypeEnum];
export interface DropletActionsPostByTag201Response {
    actions?: Array<Action>;
}
export type DropletActionsPostByTagRequest = ({
    type: "disable_backups";
} & DropletAction) | ({
    type: "enable_backups";
} & DropletAction) | ({
    type: "enable_ipv6";
} & DropletAction) | ({
    type: "power_cycle";
} & DropletAction) | ({
    type: "power_off";
} & DropletAction) | ({
    type: "power_on";
} & DropletAction) | ({
    type: "shutdown";
} & DropletAction) | ({
    type: "snapshot";
} & DropletActionSnapshot);
export interface DropletActionsPostRequest {
    type: DropletActionsPostRequestTypeEnum;
    image?: DropletActionRebuildAllOfImage;
    disk?: boolean;
    size?: string;
    name?: string;
    kernel?: number;
}
export declare const DropletActionsPostRequestTypeEnum: {
    readonly EnableBackups: "enable_backups";
    readonly DisableBackups: "disable_backups";
    readonly Reboot: "reboot";
    readonly PowerCycle: "power_cycle";
    readonly Shutdown: "shutdown";
    readonly PowerOff: "power_off";
    readonly PowerOn: "power_on";
    readonly Restore: "restore";
    readonly PasswordReset: "password_reset";
    readonly Resize: "resize";
    readonly Rebuild: "rebuild";
    readonly Rename: "rename";
    readonly ChangeKernel: "change_kernel";
    readonly EnableIpv6: "enable_ipv6";
    readonly Snapshot: "snapshot";
};
export type DropletActionsPostRequestTypeEnum = (typeof DropletActionsPostRequestTypeEnum)[keyof typeof DropletActionsPostRequestTypeEnum];
export interface DropletCreate {
    region?: string;
    size: string;
    image: DropletCreateImage;
    ssh_keys?: Array<DropletCreateSshKeysInner>;
    backups?: boolean;
    ipv6?: boolean;
    monitoring?: boolean;
    tags?: Array<string> | null;
    user_data?: string;
    private_networking?: boolean;
    volumes?: Array<string>;
    vpc_uuid?: string;
    with_droplet_agent?: boolean;
}
export type DropletCreateImage = number | string;
export type DropletCreateSshKeysInner = {};
export interface DropletMultiCreate {
    region?: string;
    size: string;
    image: DropletCreateImage;
    ssh_keys?: Array<DropletCreateSshKeysInner>;
    backups?: boolean;
    ipv6?: boolean;
    monitoring?: boolean;
    tags?: Array<string> | null;
    user_data?: string;
    private_networking?: boolean;
    volumes?: Array<string>;
    vpc_uuid?: string;
    with_droplet_agent?: boolean;
    names: Array<string>;
}
export interface DropletNetworks {
    v4?: Array<NetworkV4>;
    v6?: Array<NetworkV6>;
}
export interface DropletNextBackupWindow {
    start?: string;
    end?: string;
}
export interface DropletSingleCreate {
    region?: string;
    size: string;
    image: DropletCreateImage;
    ssh_keys?: Array<DropletCreateSshKeysInner>;
    backups?: boolean;
    ipv6?: boolean;
    monitoring?: boolean;
    tags?: Array<string> | null;
    user_data?: string;
    private_networking?: boolean;
    volumes?: Array<string>;
    vpc_uuid?: string;
    with_droplet_agent?: boolean;
    name: string;
}
export interface DropletSnapshot {
    name: string;
    created_at: string;
    regions: Array<string>;
    min_disk_size: number;
    size_gigabytes: number;
    id: number;
    type: DropletSnapshotTypeEnum;
}
export declare const DropletSnapshotTypeEnum: {
    readonly Snapshot: "snapshot";
    readonly Backup: "backup";
};
export type DropletSnapshotTypeEnum = (typeof DropletSnapshotTypeEnum)[keyof typeof DropletSnapshotTypeEnum];
export type DropletsCreate202Response = MultipleDropletResponse | SingleDropletResponse;
export type DropletsCreateRequest = DropletMultiCreate | DropletSingleCreate;
export interface DropletsGet200Response {
    droplet?: Droplet;
}
export interface DropletsList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    droplets?: Array<Droplet>;
}
export interface DropletsListAssociatedResources200Response {
    reserved_ips?: Array<AssociatedResource>;
    floating_ips?: Array<AssociatedResource>;
    snapshots?: Array<AssociatedResource>;
    volumes?: Array<AssociatedResource>;
    volume_snapshots?: Array<AssociatedResource>;
}
export interface DropletsListBackups200Response {
    links?: PageLinks;
    meta: MetaMeta;
    backups?: Array<DropletSnapshot>;
}
export interface DropletsListFirewalls200Response {
    links?: PageLinks;
    meta: MetaMeta;
    firewalls?: Array<Firewall>;
}
export interface DropletsListKernels200Response {
    links?: PageLinks;
    meta: MetaMeta;
    kernels?: Array<Kernel>;
}
export interface DropletsListNeighbors200Response {
    droplets?: Array<Droplet>;
}
export interface DropletsListSnapshots200Response {
    links?: PageLinks;
    meta: MetaMeta;
    snapshots?: Array<DropletSnapshot>;
}
export interface ElasticsearchLogsink {
    url: string;
    index_prefix: string;
    index_days_max?: number;
    timeout?: number;
    ca?: string;
}
export interface ErrorWithRootCauses {
    error: string;
    messages?: Array<string> | null;
    root_causes: Array<string>;
}
export interface EventsLogs {
    id?: string;
    cluster_name?: string;
    event_type?: EventsLogsEventTypeEnum;
    create_time?: string;
}
export declare const EventsLogsEventTypeEnum: {
    readonly MaintenancePerform: "cluster_maintenance_perform";
    readonly MasterPromotion: "cluster_master_promotion";
    readonly Create: "cluster_create";
    readonly Update: "cluster_update";
    readonly Delete: "cluster_delete";
    readonly Poweron: "cluster_poweron";
    readonly Poweroff: "cluster_poweroff";
};
export type EventsLogsEventTypeEnum = (typeof EventsLogsEventTypeEnum)[keyof typeof EventsLogsEventTypeEnum];
export declare const EvictionPolicyModel: {
    readonly Noeviction: "noeviction";
    readonly AllkeysLru: "allkeys_lru";
    readonly AllkeysRandom: "allkeys_random";
    readonly VolatileLru: "volatile_lru";
    readonly VolatileRandom: "volatile_random";
    readonly VolatileTtl: "volatile_ttl";
};
export type EvictionPolicyModel = (typeof EvictionPolicyModel)[keyof typeof EvictionPolicyModel];
export interface Firewall {
    inbound_rules?: Array<FirewallRulesInboundRulesInner> | null;
    outbound_rules?: Array<FirewallRulesOutboundRulesInner> | null;
    id?: string;
    status?: FirewallStatusEnum;
    created_at?: string;
    pending_changes?: Array<FirewallAllOfPendingChanges>;
    name?: string;
    droplet_ids?: Array<number> | null;
    tags?: FirewallAllOfTags;
}
export declare const FirewallStatusEnum: {
    readonly Waiting: "waiting";
    readonly Succeeded: "succeeded";
    readonly Failed: "failed";
};
export type FirewallStatusEnum = (typeof FirewallStatusEnum)[keyof typeof FirewallStatusEnum];
export interface FirewallAllOfPendingChanges {
    droplet_id?: number;
    removing?: boolean;
    status?: string;
}
export type FirewallAllOfTags = {};
export interface FirewallRule {
    uuid?: string;
    cluster_uuid?: string;
    type: FirewallRuleTypeEnum;
    value: string;
    created_at?: string;
}
export declare const FirewallRuleTypeEnum: {
    readonly Droplet: "droplet";
    readonly K8s: "k8s";
    readonly IpAddr: "ip_addr";
    readonly Tag: "tag";
    readonly App: "app";
};
export type FirewallRuleTypeEnum = (typeof FirewallRuleTypeEnum)[keyof typeof FirewallRuleTypeEnum];
export interface FirewallRuleBase {
    protocol: FirewallRuleBaseProtocolEnum;
    ports: string;
}
export declare const FirewallRuleBaseProtocolEnum: {
    readonly Tcp: "tcp";
    readonly Udp: "udp";
    readonly Icmp: "icmp";
};
export type FirewallRuleBaseProtocolEnum = (typeof FirewallRuleBaseProtocolEnum)[keyof typeof FirewallRuleBaseProtocolEnum];
export interface FirewallRuleTarget {
    addresses?: Array<string>;
    droplet_ids?: Array<number>;
    load_balancer_uids?: Array<string>;
    kubernetes_ids?: Array<string>;
    tags?: Array<string> | null;
}
export interface FirewallRules {
    inbound_rules?: Array<FirewallRulesInboundRulesInner> | null;
    outbound_rules?: Array<FirewallRulesOutboundRulesInner> | null;
}
export interface FirewallRulesInboundRulesInner {
    protocol: FirewallRulesInboundRulesInnerProtocolEnum;
    ports: string;
    sources: FirewallRuleTarget;
}
export declare const FirewallRulesInboundRulesInnerProtocolEnum: {
    readonly Tcp: "tcp";
    readonly Udp: "udp";
    readonly Icmp: "icmp";
};
export type FirewallRulesInboundRulesInnerProtocolEnum = (typeof FirewallRulesInboundRulesInnerProtocolEnum)[keyof typeof FirewallRulesInboundRulesInnerProtocolEnum];
export interface FirewallRulesOutboundRulesInner {
    protocol: FirewallRulesOutboundRulesInnerProtocolEnum;
    ports: string;
    destinations: FirewallRuleTarget;
}
export declare const FirewallRulesOutboundRulesInnerProtocolEnum: {
    readonly Tcp: "tcp";
    readonly Udp: "udp";
    readonly Icmp: "icmp";
};
export type FirewallRulesOutboundRulesInnerProtocolEnum = (typeof FirewallRulesOutboundRulesInnerProtocolEnum)[keyof typeof FirewallRulesOutboundRulesInnerProtocolEnum];
export interface FirewallsAddRulesRequest {
    inbound_rules?: Array<FirewallRulesInboundRulesInner> | null;
    outbound_rules?: Array<FirewallRulesOutboundRulesInner> | null;
}
export interface FirewallsAddTagsRequest {
    tags: Array<string> | null;
}
export interface FirewallsAssignDropletsRequest {
    droplet_ids: Array<number>;
}
export interface FirewallsCreate202Response {
    firewall?: Firewall;
}
export interface FirewallsCreateRequest {
    id?: string;
    status?: FirewallsCreateRequestStatusEnum;
    created_at?: string;
    pending_changes?: Array<FirewallAllOfPendingChanges>;
    name: string;
    droplet_ids?: Array<number> | null;
    tags?: FirewallAllOfTags;
    inbound_rules?: Array<FirewallRulesInboundRulesInner> | null;
    outbound_rules?: Array<FirewallRulesOutboundRulesInner> | null;
}
export declare const FirewallsCreateRequestStatusEnum: {
    readonly Waiting: "waiting";
    readonly Succeeded: "succeeded";
    readonly Failed: "failed";
};
export type FirewallsCreateRequestStatusEnum = (typeof FirewallsCreateRequestStatusEnum)[keyof typeof FirewallsCreateRequestStatusEnum];
export interface FirewallsDeleteDropletsRequest {
    droplet_ids: Array<number>;
}
export interface FirewallsUpdateRequest {
    id?: string;
    status?: FirewallsUpdateRequestStatusEnum;
    created_at?: string;
    pending_changes?: Array<FirewallAllOfPendingChanges>;
    name: string;
    droplet_ids?: Array<number> | null;
    tags?: FirewallAllOfTags;
    inbound_rules?: Array<FirewallRulesInboundRulesInner> | null;
    outbound_rules?: Array<FirewallRulesOutboundRulesInner> | null;
}
export declare const FirewallsUpdateRequestStatusEnum: {
    readonly Waiting: "waiting";
    readonly Succeeded: "succeeded";
    readonly Failed: "failed";
};
export type FirewallsUpdateRequestStatusEnum = (typeof FirewallsUpdateRequestStatusEnum)[keyof typeof FirewallsUpdateRequestStatusEnum];
export interface FloatingIPsAction {
    type: FloatingIPsActionTypeEnum;
}
export declare const FloatingIPsActionTypeEnum: {
    readonly Assign: "assign";
    readonly Unassign: "unassign";
};
export type FloatingIPsActionTypeEnum = (typeof FloatingIPsActionTypeEnum)[keyof typeof FloatingIPsActionTypeEnum];
export interface FloatingIPsActionList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    actions?: Array<Action>;
}
export interface FloatingIPsActionPost201Response {
    action?: FloatingIPsActionPost201ResponseAction;
}
export interface FloatingIPsActionPost201ResponseAction {
    id?: number;
    status?: FloatingIPsActionPost201ResponseActionStatusEnum;
    type?: string;
    started_at?: string;
    completed_at?: string | null;
    resource_id?: number | null;
    resource_type?: string;
    region?: Region;
    region_slug?: string;
    project_id?: string;
}
export declare const FloatingIPsActionPost201ResponseActionStatusEnum: {
    readonly InProgress: "in-progress";
    readonly Completed: "completed";
    readonly Errored: "errored";
};
export type FloatingIPsActionPost201ResponseActionStatusEnum = (typeof FloatingIPsActionPost201ResponseActionStatusEnum)[keyof typeof FloatingIPsActionPost201ResponseActionStatusEnum];
export interface FloatingIPsActionPostRequest {
    type: FloatingIPsActionPostRequestTypeEnum;
    droplet_id: number;
}
export declare const FloatingIPsActionPostRequestTypeEnum: {
    readonly Assign: "assign";
    readonly Unassign: "unassign";
};
export type FloatingIPsActionPostRequestTypeEnum = (typeof FloatingIPsActionPostRequestTypeEnum)[keyof typeof FloatingIPsActionPostRequestTypeEnum];
export interface FloatingIPsCreate202Response {
    floating_ip?: FloatingIp;
    links?: FloatingIPsCreate202ResponseLinks;
}
export interface FloatingIPsCreate202ResponseLinks {
    droplets?: Array<ActionLink>;
    actions?: Array<ActionLink>;
}
export interface FloatingIPsGet200Response {
    floating_ip?: FloatingIp;
}
export interface FloatingIPsList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    floating_ips?: Array<FloatingIp>;
}
export interface FloatingIp {
    ip?: string;
    region?: FloatingIpRegion;
    droplet?: FloatingIpDroplet;
    locked?: boolean;
    project_id?: string;
}
export interface FloatingIpActionAssign extends FloatingIPsAction {
    droplet_id: number;
}
export interface FloatingIpActionUnassign extends FloatingIPsAction {
}
export type FloatingIpCreate = AssignToDroplet | ReserveToRegion;
export interface FloatingIpDroplet {
    id: number;
    name: string;
    memory: number;
    vcpus: number;
    disk: number;
    locked: boolean;
    status: FloatingIpDropletStatusEnum;
    kernel?: Kernel | null;
    created_at: string;
    features: Array<string>;
    backup_ids: Array<number>;
    next_backup_window: DropletNextBackupWindow | null;
    snapshot_ids: Array<number>;
    image: Image;
    volume_ids: Array<string>;
    size: Size;
    size_slug: string;
    networks: DropletNetworks;
    region: Region;
    tags: Array<string>;
    vpc_uuid?: string;
}
export declare const FloatingIpDropletStatusEnum: {
    readonly New: "new";
    readonly Active: "active";
    readonly Off: "off";
    readonly Archive: "archive";
};
export type FloatingIpDropletStatusEnum = (typeof FloatingIpDropletStatusEnum)[keyof typeof FloatingIpDropletStatusEnum];
export interface FloatingIpRegion {
    name: string;
    slug: string;
    features: Array<string>;
    available: boolean;
    sizes: Array<string>;
}
export interface ForwardLinks {
    last?: string;
    next?: string;
}
export interface ForwardingRule {
    entry_protocol: ForwardingRuleEntryProtocolEnum;
    entry_port: number;
    target_protocol: ForwardingRuleTargetProtocolEnum;
    target_port: number;
    certificate_id?: string;
    tls_passthrough?: boolean;
}
export declare const ForwardingRuleEntryProtocolEnum: {
    readonly Http: "http";
    readonly Https: "https";
    readonly Http2: "http2";
    readonly Http3: "http3";
    readonly Tcp: "tcp";
    readonly Udp: "udp";
};
export type ForwardingRuleEntryProtocolEnum = (typeof ForwardingRuleEntryProtocolEnum)[keyof typeof ForwardingRuleEntryProtocolEnum];
export declare const ForwardingRuleTargetProtocolEnum: {
    readonly Http: "http";
    readonly Https: "https";
    readonly Http2: "http2";
    readonly Tcp: "tcp";
    readonly Udp: "udp";
};
export type ForwardingRuleTargetProtocolEnum = (typeof ForwardingRuleTargetProtocolEnum)[keyof typeof ForwardingRuleTargetProtocolEnum];
export interface FunctionsCreateNamespace200Response {
    namespace?: NamespaceInfo;
}
export interface FunctionsCreateTrigger200Response {
    trigger?: TriggerInfo;
}
export interface FunctionsListNamespaces200Response {
    namespaces?: Array<NamespaceInfo>;
}
export interface FunctionsListTriggers200Response {
    triggers?: Array<TriggerInfo>;
}
export interface GarbageCollection {
    uuid?: string;
    registry_name?: string;
    status?: GarbageCollectionStatusEnum;
    created_at?: string;
    updated_at?: string;
    blobs_deleted?: number;
    freed_bytes?: number;
}
export declare const GarbageCollectionStatusEnum: {
    readonly Requested: "requested";
    readonly WaitingForWriteJwtsToExpire: "waiting for write JWTs to expire";
    readonly ScanningManifests: "scanning manifests";
    readonly DeletingUnreferencedBlobs: "deleting unreferenced blobs";
    readonly Cancelling: "cancelling";
    readonly Failed: "failed";
    readonly Succeeded: "succeeded";
    readonly Cancelled: "cancelled";
};
export type GarbageCollectionStatusEnum = (typeof GarbageCollectionStatusEnum)[keyof typeof GarbageCollectionStatusEnum];
export interface HealthCheck {
    protocol?: HealthCheckProtocolEnum;
    port?: number;
    path?: string;
    check_interval_seconds?: number;
    response_timeout_seconds?: number;
    unhealthy_threshold?: number;
    healthy_threshold?: number;
}
export declare const HealthCheckProtocolEnum: {
    readonly Http: "http";
    readonly Https: "https";
    readonly Tcp: "tcp";
};
export type HealthCheckProtocolEnum = (typeof HealthCheckProtocolEnum)[keyof typeof HealthCheckProtocolEnum];
export interface Image {
    id?: number;
    name?: string;
    type?: ImageTypeEnum;
    distribution?: Distribution;
    slug?: string | null;
    public?: boolean;
    regions?: Array<RegionSlug>;
    created_at?: string;
    min_disk_size?: number | null;
    size_gigabytes?: number | null;
    description?: string;
    tags?: Array<string> | null;
    status?: ImageStatusEnum;
    error_message?: string;
}
export declare const ImageTypeEnum: {
    readonly Base: "base";
    readonly Snapshot: "snapshot";
    readonly Backup: "backup";
    readonly Custom: "custom";
    readonly Admin: "admin";
};
export type ImageTypeEnum = (typeof ImageTypeEnum)[keyof typeof ImageTypeEnum];
export declare const ImageStatusEnum: {
    readonly New: "NEW";
    readonly Available: "available";
    readonly Pending: "pending";
    readonly Deleted: "deleted";
    readonly Retired: "retired";
};
export type ImageStatusEnum = (typeof ImageStatusEnum)[keyof typeof ImageStatusEnum];
export interface ImageActionBase {
    type: ImageActionBaseTypeEnum;
}
export declare const ImageActionBaseTypeEnum: {
    readonly Convert: "convert";
    readonly Transfer: "transfer";
};
export type ImageActionBaseTypeEnum = (typeof ImageActionBaseTypeEnum)[keyof typeof ImageActionBaseTypeEnum];
export interface ImageActionTransfer {
    type: ImageActionTransferTypeEnum;
    region: RegionSlug;
}
export declare const ImageActionTransferTypeEnum: {
    readonly Convert: "convert";
    readonly Transfer: "transfer";
};
export type ImageActionTransferTypeEnum = (typeof ImageActionTransferTypeEnum)[keyof typeof ImageActionTransferTypeEnum];
export interface ImageActionsPostRequest {
    type: ImageActionsPostRequestTypeEnum;
    region: RegionSlug;
}
export declare const ImageActionsPostRequestTypeEnum: {
    readonly Convert: "convert";
    readonly Transfer: "transfer";
};
export type ImageActionsPostRequestTypeEnum = (typeof ImageActionsPostRequestTypeEnum)[keyof typeof ImageActionsPostRequestTypeEnum];
export interface ImageNewCustom {
    name: string;
    distribution?: Distribution;
    description?: string;
    url: string;
    region: RegionSlug;
    tags?: Array<string> | null;
}
export interface ImageUpdate {
    name?: string;
    distribution?: Distribution;
    description?: string;
}
export interface ImagesCreateCustom202Response {
    image?: Image;
}
export interface ImagesGet200Response {
    image: Image;
}
export type ImagesGetImageIdParameter = {};
export interface ImagesList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    images: Array<Image>;
}
export declare const InstanceSizeCpuType: {
    readonly Unspecified: "UNSPECIFIED";
    readonly Shared: "SHARED";
    readonly Dedicated: "DEDICATED";
};
export type InstanceSizeCpuType = (typeof InstanceSizeCpuType)[keyof typeof InstanceSizeCpuType];
export interface InvoiceItem {
    product?: string;
    resource_uuid?: string;
    resource_id?: string;
    group_description?: string;
    description?: string;
    amount?: string;
    duration?: string;
    duration_unit?: string;
    start_time?: string;
    end_time?: string;
    project_name?: string;
}
export interface InvoicePreview {
    invoice_uuid?: string;
    invoice_id?: string;
    amount?: string;
    invoice_period?: string;
    updated_at?: string;
}
export interface InvoiceSummary {
    invoice_uuid?: string;
    invoice_id?: string;
    billing_period?: string;
    amount?: string;
    user_name?: string;
    user_billing_address?: InvoiceSummaryUserBillingAddress;
    user_company?: string;
    user_email?: string;
    product_charges?: InvoiceSummaryProductCharges;
    overages?: InvoiceSummaryOverages;
    taxes?: InvoiceSummaryTaxes;
    credits_and_adjustments?: InvoiceSummaryCreditsAndAdjustments;
}
export interface InvoiceSummaryCreditsAndAdjustments {
    name?: string;
    amount?: string;
}
export interface InvoiceSummaryOverages {
    name?: string;
    amount?: string;
}
export interface InvoiceSummaryProductCharges {
    name?: string;
    amount?: string;
    items?: Array<ProductChargeItem>;
}
export interface InvoiceSummaryTaxes {
    name?: string;
    amount?: string;
}
export interface InvoiceSummaryUserBillingAddress {
    address_line1?: string;
    address_line2?: string;
    city?: string;
    region?: string;
    postal_code?: string;
    country_iso2_code?: string;
    created_at?: string;
    updated_at?: string;
}
export interface InvoicesGetByUUID200Response {
    links?: PageLinks;
    meta: MetaMeta;
    invoice_items?: Array<InvoiceItem>;
}
export interface InvoicesList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    invoices?: Array<InvoicePreview>;
    invoice_preview?: InvoicePreview;
}
export interface KafkaAdvancedConfig {
    compression_type?: KafkaAdvancedConfigCompressionTypeEnum;
    group_initial_rebalance_delay_ms?: number;
    group_min_session_timeout_ms?: number;
    group_max_session_timeout_ms?: number;
    connections_max_idle_ms?: number;
    max_incremental_fetch_session_cache_slots?: number;
    message_max_bytes?: number;
    offsets_retention_minutes?: number;
    log_cleaner_delete_retention_ms?: number;
    log_cleaner_min_cleanable_ratio?: number;
    log_cleaner_max_compaction_lag_ms?: number;
    log_cleaner_min_compaction_lag_ms?: number;
    log_cleanup_policy?: KafkaAdvancedConfigLogCleanupPolicyEnum;
    log_flush_interval_messages?: number;
    log_flush_interval_ms?: number;
    log_index_interval_bytes?: number;
    log_index_size_max_bytes?: number;
    log_message_downconversion_enable?: boolean;
    log_message_timestamp_type?: KafkaAdvancedConfigLogMessageTimestampTypeEnum;
    log_message_timestamp_difference_max_ms?: number;
    log_preallocate?: boolean;
    log_retention_bytes?: number;
    log_retention_hours?: number;
    log_retention_ms?: number;
    log_roll_jitter_ms?: number;
    log_roll_ms?: number;
    log_segment_bytes?: number;
    log_segment_delete_delay_ms?: number;
    auto_create_topics_enable?: boolean;
    min_insync_replicas?: number;
    num_partitions?: number;
    default_replication_factor?: number;
    replica_fetch_max_bytes?: number;
    replica_fetch_response_max_bytes?: number;
    max_connections_per_ip?: number;
    producer_purgatory_purge_interval_requests?: number;
    socket_request_max_bytes?: number;
    transaction_state_log_segment_bytes?: number;
    transaction_remove_expired_transaction_cleanup_interval_ms?: number;
}
export declare const KafkaAdvancedConfigCompressionTypeEnum: {
    readonly Gzip: "gzip";
    readonly Snappy: "snappy";
    readonly Lz4: "lz4";
    readonly Zstd: "zstd";
    readonly Uncompressed: "uncompressed";
    readonly Producer: "producer";
};
export type KafkaAdvancedConfigCompressionTypeEnum = (typeof KafkaAdvancedConfigCompressionTypeEnum)[keyof typeof KafkaAdvancedConfigCompressionTypeEnum];
export declare const KafkaAdvancedConfigLogCleanupPolicyEnum: {
    readonly Delete: "delete";
    readonly Compact: "compact";
    readonly Compactdelete: "compact,delete";
};
export type KafkaAdvancedConfigLogCleanupPolicyEnum = (typeof KafkaAdvancedConfigLogCleanupPolicyEnum)[keyof typeof KafkaAdvancedConfigLogCleanupPolicyEnum];
export declare const KafkaAdvancedConfigLogMessageTimestampTypeEnum: {
    readonly CreateTime: "CreateTime";
    readonly LogAppendTime: "LogAppendTime";
};
export type KafkaAdvancedConfigLogMessageTimestampTypeEnum = (typeof KafkaAdvancedConfigLogMessageTimestampTypeEnum)[keyof typeof KafkaAdvancedConfigLogMessageTimestampTypeEnum];
export interface KafkaTopic {
    name?: string;
    replication_factor?: number;
    partition_count?: number;
    state?: KafkaTopicStateEnum;
}
export declare const KafkaTopicStateEnum: {
    readonly Active: "active";
    readonly Configuring: "configuring";
    readonly Deleting: "deleting";
    readonly Unknown: "unknown";
};
export type KafkaTopicStateEnum = (typeof KafkaTopicStateEnum)[keyof typeof KafkaTopicStateEnum];
export interface KafkaTopicBase {
    name?: string;
    replication_factor?: number;
    partition_count?: number;
}
export interface KafkaTopicConfig {
    cleanup_policy?: KafkaTopicConfigCleanupPolicyEnum;
    compression_type?: KafkaTopicConfigCompressionTypeEnum;
    delete_retention_ms?: number;
    file_delete_delay_ms?: number;
    flush_messages?: number;
    flush_ms?: number;
    index_interval_bytes?: number;
    max_compaction_lag_ms?: number;
    max_message_bytes?: number;
    message_down_conversion_enable?: boolean;
    message_format_version?: KafkaTopicConfigMessageFormatVersionEnum;
    message_timestamp_type?: KafkaTopicConfigMessageTimestampTypeEnum;
    min_cleanable_dirty_ratio?: number;
    min_compaction_lag_ms?: number;
    min_insync_replicas?: number;
    preallocate?: boolean;
    retention_bytes?: number;
    retention_ms?: number;
    segment_bytes?: number;
    segment_jitter_ms?: number;
    segment_ms?: number;
}
export declare const KafkaTopicConfigCleanupPolicyEnum: {
    readonly Delete: "delete";
    readonly Compact: "compact";
    readonly CompactDelete: "compact_delete";
};
export type KafkaTopicConfigCleanupPolicyEnum = (typeof KafkaTopicConfigCleanupPolicyEnum)[keyof typeof KafkaTopicConfigCleanupPolicyEnum];
export declare const KafkaTopicConfigCompressionTypeEnum: {
    readonly Producer: "producer";
    readonly Gzip: "gzip";
    readonly Snappy: "snappy";
    readonly Iz4: "Iz4";
    readonly Zstd: "zstd";
    readonly Uncompressed: "uncompressed";
};
export type KafkaTopicConfigCompressionTypeEnum = (typeof KafkaTopicConfigCompressionTypeEnum)[keyof typeof KafkaTopicConfigCompressionTypeEnum];
export declare const KafkaTopicConfigMessageFormatVersionEnum: {
    readonly _080: "0.8.0";
    readonly _081: "0.8.1";
    readonly _082: "0.8.2";
    readonly _090: "0.9.0";
    readonly _0100Iv0: "0.10.0-IV0";
    readonly _0100Iv1: "0.10.0-IV1";
    readonly _0101Iv0: "0.10.1-IV0";
    readonly _0101Iv1: "0.10.1-IV1";
    readonly _0101Iv2: "0.10.1-IV2";
    readonly _0102Iv0: "0.10.2-IV0";
    readonly _0110Iv0: "0.11.0-IV0";
    readonly _0110Iv1: "0.11.0-IV1";
    readonly _0110Iv2: "0.11.0-IV2";
    readonly _10Iv0: "1.0-IV0";
    readonly _11Iv0: "1.1-IV0";
    readonly _20Iv0: "2.0-IV0";
    readonly _20Iv1: "2.0-IV1";
    readonly _21Iv0: "2.1-IV0";
    readonly _21Iv1: "2.1-IV1";
    readonly _21Iv2: "2.1-IV2";
    readonly _22Iv0: "2.2-IV0";
    readonly _22Iv1: "2.2-IV1";
    readonly _23Iv0: "2.3-IV0";
    readonly _23Iv1: "2.3-IV1";
    readonly _24Iv0: "2.4-IV0";
    readonly _24Iv1: "2.4-IV1";
    readonly _25Iv0: "2.5-IV0";
    readonly _26Iv0: "2.6-IV0";
    readonly _27Iv0: "2.7-IV0";
    readonly _27Iv1: "2.7-IV1";
    readonly _27Iv2: "2.7-IV2";
    readonly _28Iv0: "2.8-IV0";
    readonly _28Iv1: "2.8-IV1";
    readonly _30Iv0: "3.0-IV0";
    readonly _30Iv1: "3.0-IV1";
    readonly _31Iv0: "3.1-IV0";
    readonly _32Iv0: "3.2-IV0";
    readonly _33Iv0: "3.3-IV0";
    readonly _33Iv1: "3.3-IV1";
    readonly _33Iv2: "3.3-IV2";
    readonly _33Iv3: "3.3-IV3";
};
export type KafkaTopicConfigMessageFormatVersionEnum = (typeof KafkaTopicConfigMessageFormatVersionEnum)[keyof typeof KafkaTopicConfigMessageFormatVersionEnum];
export declare const KafkaTopicConfigMessageTimestampTypeEnum: {
    readonly CreateTime: "create_time";
    readonly LogAppendTime: "log_append_time";
};
export type KafkaTopicConfigMessageTimestampTypeEnum = (typeof KafkaTopicConfigMessageTimestampTypeEnum)[keyof typeof KafkaTopicConfigMessageTimestampTypeEnum];
export interface KafkaTopicCreate {
    name?: string;
    replication_factor?: number;
    partition_count?: number;
    config?: KafkaTopicConfig;
}
export interface KafkaTopicPartition {
    size?: number;
    id?: number;
    in_sync_replicas?: number;
    earliest_offset?: number;
    consumer_groups?: Array<KafkaTopicPartitionConsumerGroupsInner> | null;
}
export interface KafkaTopicPartitionConsumerGroupsInner {
    group_name?: string;
    offset?: number;
}
export interface KafkaTopicUpdate {
    replication_factor?: number;
    partition_count?: number;
    config?: KafkaTopicConfig;
}
export interface KafkaTopicVerbose {
    name?: string;
    state?: KafkaTopicVerboseStateEnum;
    replication_factor?: number;
    partitions?: Array<KafkaTopicPartition>;
    config?: KafkaTopicConfig;
}
export declare const KafkaTopicVerboseStateEnum: {
    readonly Active: "active";
    readonly Configuring: "configuring";
    readonly Deleting: "deleting";
    readonly Unknown: "unknown";
};
export type KafkaTopicVerboseStateEnum = (typeof KafkaTopicVerboseStateEnum)[keyof typeof KafkaTopicVerboseStateEnum];
export interface Kernel {
    id?: number;
    name?: string;
    version?: string;
}
export interface KubernetesAddNodePool201Response {
    node_pool?: KubernetesNodePool;
}
export interface KubernetesCreateCluster201Response {
    kubernetes_cluster?: Cluster;
}
export interface KubernetesGetAvailableUpgrades200Response {
    available_upgrade_versions?: Array<KubernetesVersion> | null;
}
export interface KubernetesGetNodePool200Response {
    node_pool?: KubernetesNodePool;
}
export interface KubernetesListClusters200Response {
    links?: PageLinks;
    meta: MetaMeta;
    kubernetes_clusters?: Array<Cluster>;
}
export interface KubernetesListNodePools200Response {
    node_pools?: Array<KubernetesNodePool>;
}
export interface KubernetesNodePool {
    size: string;
    id?: string;
    name: string;
    count: number;
    tags?: Array<string>;
    labels?: object | null;
    taints?: Array<KubernetesNodePoolTaint>;
    auto_scale?: boolean;
    min_nodes?: number;
    max_nodes?: number;
    nodes?: Array<Node>;
}
export interface KubernetesNodePoolBase {
    id?: string;
    name?: string;
    count?: number;
    tags?: Array<string>;
    labels?: object | null;
    taints?: Array<KubernetesNodePoolTaint>;
    auto_scale?: boolean;
    min_nodes?: number;
    max_nodes?: number;
    nodes?: Array<Node>;
}
export interface KubernetesNodePoolSize {
    size?: string;
}
export interface KubernetesNodePoolTaint {
    key?: string;
    value?: string;
    effect?: KubernetesNodePoolTaintEffectEnum;
}
export declare const KubernetesNodePoolTaintEffectEnum: {
    readonly NoSchedule: "NoSchedule";
    readonly PreferNoSchedule: "PreferNoSchedule";
    readonly NoExecute: "NoExecute";
};
export type KubernetesNodePoolTaintEffectEnum = (typeof KubernetesNodePoolTaintEffectEnum)[keyof typeof KubernetesNodePoolTaintEffectEnum];
export interface KubernetesNodePoolUpdate {
    id?: string;
    name: string;
    count: number;
    tags?: Array<string>;
    labels?: object | null;
    taints?: Array<KubernetesNodePoolTaint>;
    auto_scale?: boolean;
    min_nodes?: number;
    max_nodes?: number;
    nodes?: Array<Node>;
}
export interface KubernetesOptions {
    options?: KubernetesOptionsOptions;
}
export interface KubernetesOptionsOptions {
    regions?: Array<KubernetesRegion>;
    versions?: Array<KubernetesVersion>;
    sizes?: Array<KubernetesSize>;
}
export interface KubernetesRecycleNodePoolRequest {
    nodes?: Array<string>;
}
export interface KubernetesRegion {
    name?: string;
    slug?: string;
}
export interface KubernetesRunClusterLint202Response {
    run_id?: string;
}
export interface KubernetesSize {
    name?: string;
    slug?: string;
}
export interface KubernetesUpdateNodePool202Response {
    node_pool?: KubernetesNodePool;
}
export interface KubernetesUpgradeClusterRequest {
    version?: string;
}
export interface KubernetesVersion {
    slug?: string;
    kubernetes_version?: string;
    supported_features?: Array<string>;
}
export interface LbFirewall {
    deny?: Array<string>;
    allow?: Array<string>;
}
export interface LinkToFirstPage {
    first?: string;
}
export interface LinkToLastPage {
    last?: string;
}
export interface LinkToNextPage {
    next?: string;
}
export interface LinkToPrevPage {
    prev?: string;
}
export interface ListAlertPolicy {
    policies: Array<AlertPolicy>;
}
export interface LoadBalancer {
    id?: string;
    name?: string;
    project_id?: string;
    ip?: string;
    size_unit?: number;
    size?: LoadBalancerSizeEnum;
    algorithm?: LoadBalancerAlgorithmEnum;
    status?: LoadBalancerStatusEnum;
    created_at?: string;
    forwarding_rules: Array<ForwardingRule>;
    health_check?: HealthCheck;
    sticky_sessions?: StickySessions;
    redirect_http_to_https?: boolean;
    enable_proxy_protocol?: boolean;
    enable_backend_keepalive?: boolean;
    http_idle_timeout_seconds?: number;
    vpc_uuid?: string;
    disable_lets_encrypt_dns_records?: boolean;
    firewall?: LbFirewall;
    region?: object;
    droplet_ids?: Array<number>;
    tag?: string;
}
export declare const LoadBalancerSizeEnum: {
    readonly Small: "lb-small";
    readonly Medium: "lb-medium";
    readonly Large: "lb-large";
};
export type LoadBalancerSizeEnum = (typeof LoadBalancerSizeEnum)[keyof typeof LoadBalancerSizeEnum];
export declare const LoadBalancerAlgorithmEnum: {
    readonly RoundRobin: "round_robin";
    readonly LeastConnections: "least_connections";
};
export type LoadBalancerAlgorithmEnum = (typeof LoadBalancerAlgorithmEnum)[keyof typeof LoadBalancerAlgorithmEnum];
export declare const LoadBalancerStatusEnum: {
    readonly New: "new";
    readonly Active: "active";
    readonly Errored: "errored";
};
export type LoadBalancerStatusEnum = (typeof LoadBalancerStatusEnum)[keyof typeof LoadBalancerStatusEnum];
export interface LoadBalancerBase {
    id?: string;
    name?: string;
    project_id?: string;
    ip?: string;
    size_unit?: number;
    size?: LoadBalancerBaseSizeEnum;
    algorithm?: LoadBalancerBaseAlgorithmEnum;
    status?: LoadBalancerBaseStatusEnum;
    created_at?: string;
    forwarding_rules: Array<ForwardingRule>;
    health_check?: HealthCheck;
    sticky_sessions?: StickySessions;
    redirect_http_to_https?: boolean;
    enable_proxy_protocol?: boolean;
    enable_backend_keepalive?: boolean;
    http_idle_timeout_seconds?: number;
    vpc_uuid?: string;
    disable_lets_encrypt_dns_records?: boolean;
    firewall?: LbFirewall;
}
export declare const LoadBalancerBaseSizeEnum: {
    readonly Small: "lb-small";
    readonly Medium: "lb-medium";
    readonly Large: "lb-large";
};
export type LoadBalancerBaseSizeEnum = (typeof LoadBalancerBaseSizeEnum)[keyof typeof LoadBalancerBaseSizeEnum];
export declare const LoadBalancerBaseAlgorithmEnum: {
    readonly RoundRobin: "round_robin";
    readonly LeastConnections: "least_connections";
};
export type LoadBalancerBaseAlgorithmEnum = (typeof LoadBalancerBaseAlgorithmEnum)[keyof typeof LoadBalancerBaseAlgorithmEnum];
export declare const LoadBalancerBaseStatusEnum: {
    readonly New: "new";
    readonly Active: "active";
    readonly Errored: "errored";
};
export type LoadBalancerBaseStatusEnum = (typeof LoadBalancerBaseStatusEnum)[keyof typeof LoadBalancerBaseStatusEnum];
export type LoadBalancerCreate = AssignDropletsByID | AssignDropletsByTag;
export interface LoadBalancersAddDropletsRequest {
    droplet_ids: Array<number>;
}
export interface LoadBalancersAddForwardingRulesRequest {
    forwarding_rules: Array<ForwardingRule>;
}
export interface LoadBalancersCreate202Response {
    load_balancer?: LoadBalancer;
}
export interface LoadBalancersList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    load_balancers?: Array<LoadBalancer>;
}
export interface LogsinkBase {
    sink_name?: string;
    sink_type?: LogsinkBaseSinkTypeEnum;
}
export declare const LogsinkBaseSinkTypeEnum: {
    readonly Rsyslog: "rsyslog";
    readonly Elasticsearch: "elasticsearch";
    readonly Opensearch: "opensearch";
};
export type LogsinkBaseSinkTypeEnum = (typeof LogsinkBaseSinkTypeEnum)[keyof typeof LogsinkBaseSinkTypeEnum];
export interface LogsinkBaseVerbose {
    sink_id?: string;
    sink_name?: string;
    sink_type?: LogsinkBaseVerboseSinkTypeEnum;
}
export declare const LogsinkBaseVerboseSinkTypeEnum: {
    readonly Rsyslog: "rsyslog";
    readonly Elasticsearch: "elasticsearch";
    readonly Opensearch: "opensearch";
};
export type LogsinkBaseVerboseSinkTypeEnum = (typeof LogsinkBaseVerboseSinkTypeEnum)[keyof typeof LogsinkBaseVerboseSinkTypeEnum];
export interface LogsinkCreate {
    sink_name?: string;
    sink_type?: LogsinkCreateSinkTypeEnum;
    config?: LogsinkCreateAllOfConfig;
}
export declare const LogsinkCreateSinkTypeEnum: {
    readonly Rsyslog: "rsyslog";
    readonly Elasticsearch: "elasticsearch";
    readonly Opensearch: "opensearch";
};
export type LogsinkCreateSinkTypeEnum = (typeof LogsinkCreateSinkTypeEnum)[keyof typeof LogsinkCreateSinkTypeEnum];
export interface LogsinkCreateAllOfConfig {
    server: string;
    port: number;
    tls: boolean;
    format: LogsinkCreateAllOfConfigFormatEnum;
    logline?: string;
    sd?: string;
    ca?: string;
    key?: string;
    cert?: string;
    url: string;
    index_prefix: string;
    index_days_max?: number;
    timeout?: number;
}
export declare const LogsinkCreateAllOfConfigFormatEnum: {
    readonly Rfc5424: "rfc5424";
    readonly Rfc3164: "rfc3164";
    readonly Custom: "custom";
};
export type LogsinkCreateAllOfConfigFormatEnum = (typeof LogsinkCreateAllOfConfigFormatEnum)[keyof typeof LogsinkCreateAllOfConfigFormatEnum];
export interface LogsinkUpdate {
    config: LogsinkCreateAllOfConfig;
}
export interface LogsinkVerbose {
    sink_id?: string;
    sink_name?: string;
    sink_type?: LogsinkVerboseSinkTypeEnum;
    config?: LogsinkVerboseAllOfConfig;
}
export declare const LogsinkVerboseSinkTypeEnum: {
    readonly Rsyslog: "rsyslog";
    readonly Elasticsearch: "elasticsearch";
    readonly Opensearch: "opensearch";
};
export type LogsinkVerboseSinkTypeEnum = (typeof LogsinkVerboseSinkTypeEnum)[keyof typeof LogsinkVerboseSinkTypeEnum];
export interface LogsinkVerboseAllOfConfig {
    server: string;
    port: number;
    tls: boolean;
    format: LogsinkVerboseAllOfConfigFormatEnum;
    logline?: string;
    sd?: string;
    ca?: string;
    key?: string;
    cert?: string;
    url: string;
    index_prefix: string;
    index_days_max?: number;
    timeout?: number;
}
export declare const LogsinkVerboseAllOfConfigFormatEnum: {
    readonly Rfc5424: "rfc5424";
    readonly Rfc3164: "rfc3164";
    readonly Custom: "custom";
};
export type LogsinkVerboseAllOfConfigFormatEnum = (typeof LogsinkVerboseAllOfConfigFormatEnum)[keyof typeof LogsinkVerboseAllOfConfigFormatEnum];
export interface MaintenancePolicy {
    start_time?: string;
    duration?: string;
    day?: MaintenancePolicyDayEnum;
}
export declare const MaintenancePolicyDayEnum: {
    readonly Any: "any";
    readonly Monday: "monday";
    readonly Tuesday: "tuesday";
    readonly Wednesday: "wednesday";
    readonly Thursday: "thursday";
    readonly Friday: "friday";
    readonly Saturday: "saturday";
    readonly Sunday: "sunday";
};
export type MaintenancePolicyDayEnum = (typeof MaintenancePolicyDayEnum)[keyof typeof MaintenancePolicyDayEnum];
export interface Meta {
    meta: MetaMeta;
}
export interface MetaMeta {
    total: number;
}
export interface MetaOptionalTotal {
    meta: MetaProperties;
}
export interface MetaProperties {
    total?: number;
}
export interface Metrics {
    data: MetricsData;
    status: MetricsStatusEnum;
}
export declare const MetricsStatusEnum: {
    readonly Success: "success";
    readonly Error: "error";
};
export type MetricsStatusEnum = (typeof MetricsStatusEnum)[keyof typeof MetricsStatusEnum];
export interface MetricsData {
    result: Array<MetricsResult>;
    resultType: MetricsDataResultTypeEnum;
}
export declare const MetricsDataResultTypeEnum: {
    readonly Matrix: "matrix";
};
export type MetricsDataResultTypeEnum = (typeof MetricsDataResultTypeEnum)[keyof typeof MetricsDataResultTypeEnum];
export interface MetricsResult {
    metric: {
        [key: string]: string;
    };
    values: Array<Array<MetricsResultValuesInnerInner>>;
}
export type MetricsResultValuesInnerInner = number | string;
export interface ModelError {
    id: string;
    message: string;
    request_id?: string;
}
export interface MongoAdvancedConfig {
    default_read_concern?: MongoAdvancedConfigDefaultReadConcernEnum;
    default_write_concern?: string;
    transaction_lifetime_limit_seconds?: number;
    slow_op_threshold_ms?: number;
    verbosity?: number;
}
export declare const MongoAdvancedConfigDefaultReadConcernEnum: {
    readonly Local: "local";
    readonly Available: "available";
    readonly Majority: "majority";
};
export type MongoAdvancedConfigDefaultReadConcernEnum = (typeof MongoAdvancedConfigDefaultReadConcernEnum)[keyof typeof MongoAdvancedConfigDefaultReadConcernEnum];
export interface MonitoringCreateAlertPolicy200Response {
    policy?: AlertPolicy;
}
export interface MonitoringListAlertPolicy200Response {
    policies: Array<AlertPolicy>;
    links?: PageLinks;
    meta: MetaMeta;
}
export interface MultipleDropletResponse {
    droplets: Array<Droplet>;
    links: SingleDropletResponseLinks;
}
export interface MysqlAdvancedConfig {
    backup_hour?: number;
    backup_minute?: number;
    sql_mode?: string;
    connect_timeout?: number;
    default_time_zone?: string;
    group_concat_max_len?: number;
    information_schema_stats_expiry?: number;
    innodb_ft_min_token_size?: number;
    innodb_ft_server_stopword_table?: string;
    innodb_lock_wait_timeout?: number;
    innodb_log_buffer_size?: number;
    innodb_online_alter_log_max_size?: number;
    innodb_print_all_deadlocks?: boolean;
    innodb_rollback_on_timeout?: boolean;
    interactive_timeout?: number;
    internal_tmp_mem_storage_engine?: MysqlAdvancedConfigInternalTmpMemStorageEngineEnum;
    net_read_timeout?: number;
    net_write_timeout?: number;
    sql_require_primary_key?: boolean;
    wait_timeout?: number;
    max_allowed_packet?: number;
    max_heap_table_size?: number;
    sort_buffer_size?: number;
    tmp_table_size?: number;
    slow_query_log?: boolean;
    long_query_time?: number;
    binlog_retention_period?: number;
    innodb_change_buffer_max_size?: number;
    innodb_flush_neighbors?: MysqlAdvancedConfigInnodbFlushNeighborsEnum;
    innodb_read_io_threads?: number;
    innodb_write_io_threads?: number;
    innodb_thread_concurrency?: number;
    net_buffer_length?: number;
}
export declare const MysqlAdvancedConfigInternalTmpMemStorageEngineEnum: {
    readonly TempTable: "TempTable";
    readonly Memory: "MEMORY";
};
export type MysqlAdvancedConfigInternalTmpMemStorageEngineEnum = (typeof MysqlAdvancedConfigInternalTmpMemStorageEngineEnum)[keyof typeof MysqlAdvancedConfigInternalTmpMemStorageEngineEnum];
export declare const MysqlAdvancedConfigInnodbFlushNeighborsEnum: {
    readonly NUMBER_0: 0;
    readonly NUMBER_1: 1;
    readonly NUMBER_2: 2;
};
export type MysqlAdvancedConfigInnodbFlushNeighborsEnum = (typeof MysqlAdvancedConfigInnodbFlushNeighborsEnum)[keyof typeof MysqlAdvancedConfigInnodbFlushNeighborsEnum];
export interface MysqlSettings {
    auth_plugin: MysqlSettingsAuthPluginEnum;
}
export declare const MysqlSettingsAuthPluginEnum: {
    readonly MysqlNativePassword: "mysql_native_password";
    readonly CachingSha2Password: "caching_sha2_password";
};
export type MysqlSettingsAuthPluginEnum = (typeof MysqlSettingsAuthPluginEnum)[keyof typeof MysqlSettingsAuthPluginEnum];
export interface NamespaceInfo {
    api_host?: string;
    namespace?: string;
    created_at?: string;
    updated_at?: string;
    label?: string;
    region?: string;
    uuid?: string;
    key?: string;
}
export interface NeighborIds {
    neighbor_ids?: Array<Array<number>>;
}
export interface NetworkV4 {
    ip_address?: string;
    netmask?: string;
    gateway?: string;
    type?: NetworkV4TypeEnum;
}
export declare const NetworkV4TypeEnum: {
    readonly Public: "public";
    readonly Private: "private";
};
export type NetworkV4TypeEnum = (typeof NetworkV4TypeEnum)[keyof typeof NetworkV4TypeEnum];
export interface NetworkV6 {
    ip_address?: string;
    netmask?: number;
    gateway?: string;
    type?: NetworkV6TypeEnum;
}
export declare const NetworkV6TypeEnum: {
    readonly Public: "public";
};
export type NetworkV6TypeEnum = (typeof NetworkV6TypeEnum)[keyof typeof NetworkV6TypeEnum];
export interface Node {
    id?: string;
    name?: string;
    status?: NodeStatus;
    droplet_id?: string;
    created_at?: string;
    updated_at?: string;
}
export interface NodeStatus {
    state?: NodeStatusStateEnum;
}
export declare const NodeStatusStateEnum: {
    readonly Provisioning: "provisioning";
    readonly Running: "running";
    readonly Draining: "draining";
    readonly Deleting: "deleting";
};
export type NodeStatusStateEnum = (typeof NodeStatusStateEnum)[keyof typeof NodeStatusStateEnum];
export interface Notification {
    email: Array<string>;
    slack: Array<NotificationSlackInner>;
}
export interface NotificationSlackInner {
    channel: string;
    url: string;
}
export interface OneClicks {
    slug: string;
    type: string;
}
export interface OneClicksCreate {
    addon_slugs: Array<string>;
    cluster_uuid: string;
}
export interface OneClicksInstallKubernetes200Response {
    message?: string;
}
export interface OneClicksList200Response {
    "1_clicks"?: Array<OneClicks>;
}
export interface OnlineMigration {
    id?: string;
    status?: OnlineMigrationStatusEnum;
    created_at?: string;
}
export declare const OnlineMigrationStatusEnum: {
    readonly Running: "running";
    readonly Canceled: "canceled";
    readonly Error: "error";
    readonly Done: "done";
};
export type OnlineMigrationStatusEnum = (typeof OnlineMigrationStatusEnum)[keyof typeof OnlineMigrationStatusEnum];
export interface OpensearchAdvancedConfig {
    http_max_content_length_bytes?: number;
    http_max_header_size_bytes?: number;
    http_max_initial_line_length_bytes?: number;
    indices_query_bool_max_clause_count?: number;
    indices_fielddata_cache_size_percentage?: number;
    indices_memory_index_buffer_size_percentage?: number;
    indices_memory_min_index_buffer_size_mb?: number;
    indices_memory_max_index_buffer_size_mb?: number;
    indices_queries_cache_size_percentage?: number;
    indices_recovery_max_mb_per_sec?: number;
    indices_recovery_max_concurrent_file_chunks?: number;
    thread_pool_search_size?: number;
    thread_pool_search_throttled_size?: number;
    thread_pool_get_size?: number;
    thread_pool_analyze_size?: number;
    thread_pool_write_size?: number;
    thread_pool_force_merge_size?: number;
    thread_pool_search_queue_size?: number;
    thread_pool_search_throttled_queue_size?: number;
    thread_pool_get_queue_size?: number;
    thread_pool_analyze_queue_size?: number;
    thread_pool_write_queue_size?: number;
    ism_enabled?: boolean;
    ism_history_enabled?: boolean;
    ism_history_max_age_hours?: number;
    ism_history_max_docs?: number;
    ism_history_rollover_check_period_hours?: number;
    ism_history_rollover_retention_period_days?: number;
    search_max_buckets?: number;
    action_auto_create_index_enabled?: boolean;
    enable_security_audit?: boolean;
    action_destructive_requires_name?: boolean;
    cluster_max_shards_per_node?: number;
    override_main_response_version?: boolean;
    script_max_compilations_rate?: string;
    cluster_routing_allocation_node_concurrent_recoveries?: number;
    reindex_remote_whitelist?: Array<string>;
}
export interface OpensearchConnection {
    uri?: string;
    host?: string;
    port?: number;
    user?: string;
    password?: string;
    ssl?: boolean;
}
export interface OpensearchIndex {
    index_name?: string;
    number_of_shards?: number;
    number_of_replicas?: number;
    size?: number;
    created_time?: string;
    status?: OpensearchIndexStatusEnum;
    health?: OpensearchIndexHealthEnum;
}
export declare const OpensearchIndexStatusEnum: {
    readonly Unknown: "unknown";
    readonly Open: "open";
    readonly Close: "close";
    readonly None: "none";
};
export type OpensearchIndexStatusEnum = (typeof OpensearchIndexStatusEnum)[keyof typeof OpensearchIndexStatusEnum];
export declare const OpensearchIndexHealthEnum: {
    readonly Unknown: "unknown";
    readonly Green: "green";
    readonly Yellow: "yellow";
    readonly Red: "red";
    readonly Red2: "red*";
};
export type OpensearchIndexHealthEnum = (typeof OpensearchIndexHealthEnum)[keyof typeof OpensearchIndexHealthEnum];
export interface OpensearchIndexBase {
    index_name?: string;
    number_of_shards?: number;
    number_of_replicas?: number;
    size?: number;
    created_time?: string;
}
export interface OpensearchLogsink {
    url: string;
    index_prefix: string;
    index_days_max?: number;
    timeout?: number;
    ca?: string;
}
export interface Options {
    options?: OptionsOptions;
    version_availability?: OptionsVersionAvailability;
}
export interface OptionsOptions {
    kafka?: OptionsOptionsKafka;
    mongodb?: OptionsOptionsKafka;
    pg?: OptionsOptionsKafka;
    mysql?: OptionsOptionsKafka;
    redis?: OptionsOptionsKafka;
    opensearch?: OptionsOptionsKafka;
}
export interface OptionsOptionsKafka {
    regions?: Array<string>;
    versions?: Array<string>;
    layouts?: Array<DatabaseLayoutOption>;
}
export interface OptionsVersionAvailability {
    kafka?: Array<DatabaseVersionAvailability>;
    pg?: Array<DatabaseVersionAvailability>;
    mysql?: Array<DatabaseVersionAvailability>;
    redis?: Array<DatabaseVersionAvailability>;
    mongodb?: Array<DatabaseVersionAvailability>;
    opensearch?: Array<DatabaseVersionAvailability>;
}
export interface PageLinks {
    pages?: PageLinksPages | null;
}
export interface PageLinksPages {
    last?: string;
    next?: string;
    first?: string;
    prev?: string;
}
export interface Pagination {
    links?: PageLinks;
}
export interface PgbouncerAdvancedConfig {
    server_reset_query_always?: boolean;
    ignore_startup_parameters?: Array<PgbouncerAdvancedConfigIgnoreStartupParametersEnum>;
    min_pool_size?: number;
    server_lifetime?: number;
    server_idle_timeout?: number;
    autodb_pool_size?: number;
    autodb_pool_mode?: PgbouncerAdvancedConfigAutodbPoolModeEnum;
    autodb_max_db_connections?: number;
    autodb_idle_timeout?: number;
}
export declare const PgbouncerAdvancedConfigIgnoreStartupParametersEnum: {
    readonly ExtraFloatDigits: "extra_float_digits";
    readonly SearchPath: "search_path";
};
export type PgbouncerAdvancedConfigIgnoreStartupParametersEnum = (typeof PgbouncerAdvancedConfigIgnoreStartupParametersEnum)[keyof typeof PgbouncerAdvancedConfigIgnoreStartupParametersEnum];
export declare const PgbouncerAdvancedConfigAutodbPoolModeEnum: {
    readonly Session: "session";
    readonly Transaction: "transaction";
    readonly Statement: "statement";
};
export type PgbouncerAdvancedConfigAutodbPoolModeEnum = (typeof PgbouncerAdvancedConfigAutodbPoolModeEnum)[keyof typeof PgbouncerAdvancedConfigAutodbPoolModeEnum];
export interface PostgresAdvancedConfig {
    autovacuum_freeze_max_age?: number;
    autovacuum_max_workers?: number;
    autovacuum_naptime?: number;
    autovacuum_vacuum_threshold?: number;
    autovacuum_analyze_threshold?: number;
    autovacuum_vacuum_scale_factor?: number;
    autovacuum_analyze_scale_factor?: number;
    autovacuum_vacuum_cost_delay?: number;
    autovacuum_vacuum_cost_limit?: number;
    backup_hour?: number;
    backup_minute?: number;
    bgwriter_delay?: number;
    bgwriter_flush_after?: number;
    bgwriter_lru_maxpages?: number;
    bgwriter_lru_multiplier?: number;
    deadlock_timeout?: number;
    default_toast_compression?: PostgresAdvancedConfigDefaultToastCompressionEnum;
    idle_in_transaction_session_timeout?: number;
    jit?: boolean;
    log_autovacuum_min_duration?: number;
    log_error_verbosity?: PostgresAdvancedConfigLogErrorVerbosityEnum;
    log_line_prefix?: PostgresAdvancedConfigLogLinePrefixEnum;
    log_min_duration_statement?: number;
    max_files_per_process?: number;
    max_prepared_transactions?: number;
    max_pred_locks_per_transaction?: number;
    max_locks_per_transaction?: number;
    max_stack_depth?: number;
    max_standby_archive_delay?: number;
    max_standby_streaming_delay?: number;
    max_replication_slots?: number;
    max_logical_replication_workers?: number;
    max_parallel_workers?: number;
    max_parallel_workers_per_gather?: number;
    max_worker_processes?: number;
    "pg_partman_bgw.role"?: string;
    "pg_partman_bgw.interval"?: number;
    "pg_stat_statements.track"?: PostgresAdvancedConfigPgStatStatementsTrackEnum;
    temp_file_limit?: number;
    timezone?: string;
    track_activity_query_size?: number;
    track_commit_timestamp?: PostgresAdvancedConfigTrackCommitTimestampEnum;
    track_functions?: PostgresAdvancedConfigTrackFunctionsEnum;
    track_io_timing?: PostgresAdvancedConfigTrackIoTimingEnum;
    max_wal_senders?: number;
    wal_sender_timeout?: number;
    wal_writer_delay?: number;
    shared_buffers_percentage?: number;
    pgbouncer?: PgbouncerAdvancedConfig;
    work_mem?: number;
    timescaledb?: TimescaledbAdvancedConfig;
    synchronous_replication?: PostgresAdvancedConfigSynchronousReplicationEnum;
    stat_monitor_enable?: boolean;
}
export declare const PostgresAdvancedConfigDefaultToastCompressionEnum: {
    readonly Lz4: "lz4";
    readonly Pglz: "pglz";
};
export type PostgresAdvancedConfigDefaultToastCompressionEnum = (typeof PostgresAdvancedConfigDefaultToastCompressionEnum)[keyof typeof PostgresAdvancedConfigDefaultToastCompressionEnum];
export declare const PostgresAdvancedConfigLogErrorVerbosityEnum: {
    readonly Terse: "TERSE";
    readonly Default: "DEFAULT";
    readonly Verbose: "VERBOSE";
};
export type PostgresAdvancedConfigLogErrorVerbosityEnum = (typeof PostgresAdvancedConfigLogErrorVerbosityEnum)[keyof typeof PostgresAdvancedConfigLogErrorVerbosityEnum];
export declare const PostgresAdvancedConfigLogLinePrefixEnum: {
    readonly Pidpuserudbdappaclienth: "pid=%p,user=%u,db=%d,app=%a,client=%h";
    readonly MPQUserudbdappa: "%m [%p] %q[user=%u,db=%d,app=%a]";
    readonly TPL1Userudbdappaclienth: "%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h";
};
export type PostgresAdvancedConfigLogLinePrefixEnum = (typeof PostgresAdvancedConfigLogLinePrefixEnum)[keyof typeof PostgresAdvancedConfigLogLinePrefixEnum];
export declare const PostgresAdvancedConfigPgStatStatementsTrackEnum: {
    readonly All: "all";
    readonly Top: "top";
    readonly None: "none";
};
export type PostgresAdvancedConfigPgStatStatementsTrackEnum = (typeof PostgresAdvancedConfigPgStatStatementsTrackEnum)[keyof typeof PostgresAdvancedConfigPgStatStatementsTrackEnum];
export declare const PostgresAdvancedConfigTrackCommitTimestampEnum: {
    readonly Off: "off";
    readonly On: "on";
};
export type PostgresAdvancedConfigTrackCommitTimestampEnum = (typeof PostgresAdvancedConfigTrackCommitTimestampEnum)[keyof typeof PostgresAdvancedConfigTrackCommitTimestampEnum];
export declare const PostgresAdvancedConfigTrackFunctionsEnum: {
    readonly All: "all";
    readonly Pl: "pl";
    readonly None: "none";
};
export type PostgresAdvancedConfigTrackFunctionsEnum = (typeof PostgresAdvancedConfigTrackFunctionsEnum)[keyof typeof PostgresAdvancedConfigTrackFunctionsEnum];
export declare const PostgresAdvancedConfigTrackIoTimingEnum: {
    readonly Off: "off";
    readonly On: "on";
};
export type PostgresAdvancedConfigTrackIoTimingEnum = (typeof PostgresAdvancedConfigTrackIoTimingEnum)[keyof typeof PostgresAdvancedConfigTrackIoTimingEnum];
export declare const PostgresAdvancedConfigSynchronousReplicationEnum: {
    readonly Off: "off";
    readonly Quorum: "quorum";
};
export type PostgresAdvancedConfigSynchronousReplicationEnum = (typeof PostgresAdvancedConfigSynchronousReplicationEnum)[keyof typeof PostgresAdvancedConfigSynchronousReplicationEnum];
export interface PreviousOutage {
    region?: string;
    started_at?: string;
    ended_at?: string;
    duration_seconds?: number;
}
export interface ProductChargeItem {
    amount?: string;
    name?: string;
    count?: string;
}
export interface ProductUsageCharges {
    name?: string;
    amount?: string;
    items?: Array<ProductChargeItem>;
}
export interface Project {
    id?: string;
    owner_uuid?: string;
    owner_id?: number;
    name?: string;
    description?: string;
    purpose?: string;
    environment?: ProjectEnvironmentEnum;
    created_at?: string;
    updated_at?: string;
    is_default?: boolean;
}
export declare const ProjectEnvironmentEnum: {
    readonly Development: "Development";
    readonly Staging: "Staging";
    readonly Production: "Production";
};
export type ProjectEnvironmentEnum = (typeof ProjectEnvironmentEnum)[keyof typeof ProjectEnvironmentEnum];
export interface ProjectAssignment {
    resources?: Array<string>;
}
export interface ProjectBase {
    id?: string;
    owner_uuid?: string;
    owner_id?: number;
    name?: string;
    description?: string;
    purpose?: string;
    environment?: ProjectBaseEnvironmentEnum;
    created_at?: string;
    updated_at?: string;
}
export declare const ProjectBaseEnvironmentEnum: {
    readonly Development: "Development";
    readonly Staging: "Staging";
    readonly Production: "Production";
};
export type ProjectBaseEnvironmentEnum = (typeof ProjectBaseEnvironmentEnum)[keyof typeof ProjectBaseEnvironmentEnum];
export interface ProjectsAssignResources200Response {
    resources?: Array<Resource>;
}
export interface ProjectsCreate201Response {
    project?: Project;
}
export interface ProjectsGetDefault200Response {
    project?: Project;
}
export interface ProjectsList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    projects?: Array<Project>;
}
export interface ProjectsListResources200Response {
    links?: PageLinks;
    meta: MetaMeta;
    resources?: Array<Resource>;
}
export interface PurgeCache {
    files: Array<string>;
}
export interface RedisAdvancedConfig {
    redis_maxmemory_policy?: EvictionPolicyModel;
    redis_pubsub_client_output_buffer_limit?: number;
    redis_number_of_databases?: number;
    redis_io_threads?: number;
    redis_lfu_log_factor?: number;
    redis_lfu_decay_time?: number;
    redis_ssl?: boolean;
    redis_timeout?: number;
    redis_notify_keyspace_events?: string;
    redis_persistence?: RedisAdvancedConfigRedisPersistenceEnum;
    redis_acl_channels_default?: RedisAdvancedConfigRedisAclChannelsDefaultEnum;
}
export declare const RedisAdvancedConfigRedisPersistenceEnum: {
    readonly Off: "off";
    readonly Rdb: "rdb";
};
export type RedisAdvancedConfigRedisPersistenceEnum = (typeof RedisAdvancedConfigRedisPersistenceEnum)[keyof typeof RedisAdvancedConfigRedisPersistenceEnum];
export declare const RedisAdvancedConfigRedisAclChannelsDefaultEnum: {
    readonly Allchannels: "allchannels";
    readonly Resetchannels: "resetchannels";
};
export type RedisAdvancedConfigRedisAclChannelsDefaultEnum = (typeof RedisAdvancedConfigRedisAclChannelsDefaultEnum)[keyof typeof RedisAdvancedConfigRedisAclChannelsDefaultEnum];
export interface Region {
    name: string;
    slug: string;
    features: Array<string>;
    available: boolean;
    sizes: Array<string>;
}
export declare const RegionSlug: {
    readonly Ams1: "ams1";
    readonly Ams2: "ams2";
    readonly Ams3: "ams3";
    readonly Blr1: "blr1";
    readonly Fra1: "fra1";
    readonly Lon1: "lon1";
    readonly Nyc1: "nyc1";
    readonly Nyc2: "nyc2";
    readonly Nyc3: "nyc3";
    readonly Sfo1: "sfo1";
    readonly Sfo2: "sfo2";
    readonly Sfo3: "sfo3";
    readonly Sgp1: "sgp1";
    readonly Tor1: "tor1";
};
export type RegionSlug = (typeof RegionSlug)[keyof typeof RegionSlug];
export interface RegionState {
    status?: RegionStateStatusEnum;
    status_changed_at?: string;
    thirty_day_uptime_percentage?: number;
}
export declare const RegionStateStatusEnum: {
    readonly Down: "DOWN";
    readonly Up: "UP";
    readonly Checking: "CHECKING";
};
export type RegionStateStatusEnum = (typeof RegionStateStatusEnum)[keyof typeof RegionStateStatusEnum];
export interface RegionalState {
    us_east?: RegionState;
    eu_west?: RegionState;
}
export interface RegionsList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    regions: Array<Region>;
}
export interface Registry {
    name?: string;
    created_at?: string;
    region?: string;
    storage_usage_bytes?: number;
    storage_usage_bytes_updated_at?: string;
    subscription?: RegistrySubscription;
}
export interface RegistryCreate {
    name: string;
    subscription_tier_slug: RegistryCreateSubscriptionTierSlugEnum;
    region?: RegistryCreateRegionEnum;
}
export declare const RegistryCreateSubscriptionTierSlugEnum: {
    readonly Starter: "starter";
    readonly Basic: "basic";
    readonly Professional: "professional";
};
export type RegistryCreateSubscriptionTierSlugEnum = (typeof RegistryCreateSubscriptionTierSlugEnum)[keyof typeof RegistryCreateSubscriptionTierSlugEnum];
export declare const RegistryCreateRegionEnum: {
    readonly Nyc3: "nyc3";
    readonly Sfo3: "sfo3";
    readonly Ams3: "ams3";
    readonly Sgp1: "sgp1";
    readonly Fra1: "fra1";
};
export type RegistryCreateRegionEnum = (typeof RegistryCreateRegionEnum)[keyof typeof RegistryCreateRegionEnum];
export interface RegistryGet200Response {
    registry?: Registry;
}
export interface RegistryGetGarbageCollection200Response {
    garbage_collection?: GarbageCollection;
}
export interface RegistryGetOptions200Response {
    options?: RegistryGetOptions200ResponseOptions;
}
export interface RegistryGetOptions200ResponseOptions {
    available_regions?: Array<string>;
    subscription_tiers?: Array<RegistryGetOptions200ResponseOptionsSubscriptionTiersInner>;
}
export interface RegistryGetOptions200ResponseOptionsSubscriptionTiersInner {
    name?: string;
    slug?: string;
    included_repositories?: number;
    included_storage_bytes?: number;
    allow_storage_overage?: boolean;
    included_bandwidth_bytes?: number;
    monthly_price_in_cents?: number;
    storage_overage_price_in_cents?: number;
    eligible?: boolean;
    eligibility_reasons?: Array<RegistryGetOptions200ResponseOptionsSubscriptionTiersInnerEligibilityReasonsEnum>;
}
export declare const RegistryGetOptions200ResponseOptionsSubscriptionTiersInnerEligibilityReasonsEnum: {
    readonly OverRepositoryLimit: "OverRepositoryLimit";
    readonly OverStorageLimit: "OverStorageLimit";
};
export type RegistryGetOptions200ResponseOptionsSubscriptionTiersInnerEligibilityReasonsEnum = (typeof RegistryGetOptions200ResponseOptionsSubscriptionTiersInnerEligibilityReasonsEnum)[keyof typeof RegistryGetOptions200ResponseOptionsSubscriptionTiersInnerEligibilityReasonsEnum];
export interface RegistryGetSubscription200Response {
    subscription?: Subscription;
}
export interface RegistryListGarbageCollections200Response {
    garbage_collections?: Array<GarbageCollection>;
}
export interface RegistryListRepositories200Response {
    links?: PageLinks;
    meta: MetaMeta;
    repositories?: Array<Repository>;
}
export interface RegistryListRepositoriesV2200Response {
    links?: PageLinks;
    meta: MetaMeta;
    repositories?: Array<RepositoryV2>;
}
export interface RegistryListRepositoryManifests200Response {
    links?: PageLinks;
    meta: MetaMeta;
    manifests?: Array<RepositoryManifest>;
}
export interface RegistryListRepositoryTags200Response {
    links?: PageLinks;
    meta: MetaMeta;
    tags?: Array<RepositoryTag>;
}
export interface RegistrySubscription {
    tier?: SubscriptionTierBase;
    created_at?: string;
    updated_at?: string;
}
export interface RegistryUpdateSubscriptionRequest {
    tier_slug?: RegistryUpdateSubscriptionRequestTierSlugEnum;
}
export declare const RegistryUpdateSubscriptionRequestTierSlugEnum: {
    readonly Starter: "starter";
    readonly Basic: "basic";
    readonly Professional: "professional";
};
export type RegistryUpdateSubscriptionRequestTierSlugEnum = (typeof RegistryUpdateSubscriptionRequestTierSlugEnum)[keyof typeof RegistryUpdateSubscriptionRequestTierSlugEnum];
export interface Repository {
    registry_name?: string;
    name?: string;
    latest_tag?: RepositoryTag;
    tag_count?: number;
}
export interface RepositoryBlob {
    digest?: string;
    compressed_size_bytes?: number;
}
export interface RepositoryManifest {
    registry_name?: string;
    repository?: string;
    digest?: string;
    compressed_size_bytes?: number;
    size_bytes?: number;
    updated_at?: string;
    tags?: Array<string>;
    blobs?: Array<RepositoryBlob>;
}
export interface RepositoryTag {
    registry_name?: string;
    repository?: string;
    tag?: string;
    manifest_digest?: string;
    compressed_size_bytes?: number;
    size_bytes?: number;
    updated_at?: string;
}
export interface RepositoryV2 {
    registry_name?: string;
    name?: string;
    latest_manifest?: RepositoryManifest;
    tag_count?: number;
    manifest_count?: number;
}
export interface ReserveToRegion {
    region: string;
    project_id?: string;
}
export interface ReserveToRegion1 {
    region: string;
    project_id?: string;
}
export interface ReservedIPsActionsList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    actions?: Array<Action>;
}
export interface ReservedIPsActionsPost201Response {
    action?: FloatingIPsActionPost201ResponseAction;
}
export interface ReservedIPsActionsPostRequest {
    type: ReservedIPsActionsPostRequestTypeEnum;
    droplet_id: number;
}
export declare const ReservedIPsActionsPostRequestTypeEnum: {
    readonly Assign: "assign";
    readonly Unassign: "unassign";
};
export type ReservedIPsActionsPostRequestTypeEnum = (typeof ReservedIPsActionsPostRequestTypeEnum)[keyof typeof ReservedIPsActionsPostRequestTypeEnum];
export interface ReservedIPsCreate202Response {
    reserved_ip?: ReservedIp;
    links?: FloatingIPsCreate202ResponseLinks;
}
export interface ReservedIPsGet200Response {
    reserved_ip?: ReservedIp;
}
export interface ReservedIPsList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    reserved_ips?: Array<ReservedIp>;
}
export interface ReservedIp {
    ip?: string;
    region?: ReservedIpRegion;
    droplet?: ReservedIpDroplet;
    locked?: boolean;
    project_id?: string;
}
export interface ReservedIpActionAssign extends ReservedIpActionType {
    droplet_id: number;
}
export interface ReservedIpActionType {
    type: ReservedIpActionTypeTypeEnum;
}
export declare const ReservedIpActionTypeTypeEnum: {
    readonly Assign: "assign";
    readonly Unassign: "unassign";
};
export type ReservedIpActionTypeTypeEnum = (typeof ReservedIpActionTypeTypeEnum)[keyof typeof ReservedIpActionTypeTypeEnum];
export interface ReservedIpActionUnassign extends ReservedIpActionType {
}
export type ReservedIpCreate = AssignToDroplet1 | ReserveToRegion1;
export interface ReservedIpDroplet {
    id: number;
    name: string;
    memory: number;
    vcpus: number;
    disk: number;
    locked: boolean;
    status: ReservedIpDropletStatusEnum;
    kernel?: Kernel | null;
    created_at: string;
    features: Array<string>;
    backup_ids: Array<number>;
    next_backup_window: DropletNextBackupWindow | null;
    snapshot_ids: Array<number>;
    image: Image;
    volume_ids: Array<string>;
    size: Size;
    size_slug: string;
    networks: DropletNetworks;
    region: Region;
    tags: Array<string>;
    vpc_uuid?: string;
}
export declare const ReservedIpDropletStatusEnum: {
    readonly New: "new";
    readonly Active: "active";
    readonly Off: "off";
    readonly Archive: "archive";
};
export type ReservedIpDropletStatusEnum = (typeof ReservedIpDropletStatusEnum)[keyof typeof ReservedIpDropletStatusEnum];
export interface ReservedIpRegion {
    name: string;
    slug: string;
    features: Array<string>;
    available: boolean;
    sizes: Array<string>;
}
export interface Resource {
    urn?: string;
    assigned_at?: string;
    links?: ResourceLinks;
    status?: ResourceStatusEnum;
}
export declare const ResourceStatusEnum: {
    readonly Ok: "ok";
    readonly NotFound: "not_found";
    readonly Assigned: "assigned";
    readonly AlreadyAssigned: "already_assigned";
    readonly ServiceDown: "service_down";
};
export type ResourceStatusEnum = (typeof ResourceStatusEnum)[keyof typeof ResourceStatusEnum];
export interface ResourceLinks {
    self?: string;
}
export interface RsyslogLogsink {
    server: string;
    port: number;
    tls: boolean;
    format: RsyslogLogsinkFormatEnum;
    logline?: string;
    sd?: string;
    ca?: string;
    key?: string;
    cert?: string;
}
export declare const RsyslogLogsinkFormatEnum: {
    readonly Rfc5424: "rfc5424";
    readonly Rfc3164: "rfc3164";
    readonly Custom: "custom";
};
export type RsyslogLogsinkFormatEnum = (typeof RsyslogLogsinkFormatEnum)[keyof typeof RsyslogLogsinkFormatEnum];
export interface ScheduledDetails {
    cron: string;
    body?: ScheduledDetailsBody | null;
}
export interface ScheduledDetailsBody {
    name?: string;
}
export interface SelectiveDestroyAssociatedResource {
    floating_ips?: Array<string>;
    reserved_ips?: Array<string>;
    snapshots?: Array<string>;
    volumes?: Array<string>;
    volume_snapshots?: Array<string>;
}
export interface SimpleCharge {
    name?: string;
    amount?: string;
}
export interface SingleDropletResponse {
    droplet: Droplet;
    links: SingleDropletResponseLinks;
}
export interface SingleDropletResponseLinks {
    actions?: Array<ActionLink>;
}
export interface Size {
    slug: string;
    memory: number;
    vcpus: number;
    disk: number;
    transfer: number;
    price_monthly: number;
    price_hourly: number;
    regions: Array<string>;
    available: boolean;
    description: string;
}
export interface SizesList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    sizes: Array<Size>;
}
export interface SlackDetails {
    channel: string;
    url: string;
}
export interface Snapshots {
    name: string;
    created_at: string;
    regions: Array<string>;
    min_disk_size: number;
    size_gigabytes: number;
    id: string;
    resource_id: string;
    resource_type: SnapshotsResourceTypeEnum;
    tags: Array<string> | null;
}
export declare const SnapshotsResourceTypeEnum: {
    readonly Droplet: "droplet";
    readonly Volume: "volume";
};
export type SnapshotsResourceTypeEnum = (typeof SnapshotsResourceTypeEnum)[keyof typeof SnapshotsResourceTypeEnum];
export interface SnapshotsBase {
    name: string;
    created_at: string;
    regions: Array<string>;
    min_disk_size: number;
    size_gigabytes: number;
}
export interface SnapshotsGet200Response {
    snapshot?: Snapshots;
}
export type SnapshotsGetSnapshotIdParameter = {};
export interface SnapshotsList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    snapshots?: Array<Snapshots>;
}
export interface SourceDatabase {
    source?: SourceDatabaseSource;
    disable_ssl?: boolean;
    ignore_dbs?: Array<string>;
}
export interface SourceDatabaseSource {
    host?: string;
    port?: number;
    dbname?: string;
    username?: string;
    password?: string;
}
export interface SqlMode {
    sql_mode: string;
}
export interface SshKeys {
    id?: number;
    fingerprint?: string;
    public_key: string;
    name: string;
}
export interface SshKeysCreate201Response {
    ssh_key?: SshKeys;
}
export type SshKeysGetSshKeyIdentifierParameter = {};
export interface SshKeysList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    ssh_keys?: Array<SshKeys>;
}
export interface SshKeysUpdateRequest {
    name?: string;
}
export interface State {
    regions?: RegionalState;
    previous_outage?: PreviousOutage;
}
export interface StickySessions {
    type?: StickySessionsTypeEnum;
    cookie_name?: string;
    cookie_ttl_seconds?: number;
}
export declare const StickySessionsTypeEnum: {
    readonly Cookies: "cookies";
    readonly None: "none";
};
export type StickySessionsTypeEnum = (typeof StickySessionsTypeEnum)[keyof typeof StickySessionsTypeEnum];
export interface Subscription {
    tier?: SubscriptionTierBase;
    created_at?: string;
    updated_at?: string;
}
export interface SubscriptionTierBase {
    name?: string;
    slug?: string;
    included_repositories?: number;
    included_storage_bytes?: number;
    allow_storage_overage?: boolean;
    included_bandwidth_bytes?: number;
    monthly_price_in_cents?: number;
    storage_overage_price_in_cents?: number;
}
export interface SubscriptionTierExtended {
    eligible?: boolean;
    eligibility_reasons?: Array<SubscriptionTierExtendedEligibilityReasonsEnum>;
}
export declare const SubscriptionTierExtendedEligibilityReasonsEnum: {
    readonly OverRepositoryLimit: "OverRepositoryLimit";
    readonly OverStorageLimit: "OverStorageLimit";
};
export type SubscriptionTierExtendedEligibilityReasonsEnum = (typeof SubscriptionTierExtendedEligibilityReasonsEnum)[keyof typeof SubscriptionTierExtendedEligibilityReasonsEnum];
export interface Tags {
    name?: string;
    resources?: TagsResources;
}
export interface TagsCreate201Response {
    tag?: Tags;
}
export interface TagsGet200Response {
    tag?: Tags;
}
export interface TagsList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    tags?: Array<Tags>;
}
export interface TagsMetadata {
    count?: number;
    last_tagged_uri?: string;
}
export interface TagsResource {
    resources: Array<TagsResourceResourcesInner>;
}
export interface TagsResourceResourcesInner {
    resource_id?: string;
    resource_type?: TagsResourceResourcesInnerResourceTypeEnum;
}
export declare const TagsResourceResourcesInnerResourceTypeEnum: {
    readonly Droplet: "droplet";
    readonly Image: "image";
    readonly Volume: "volume";
    readonly VolumeSnapshot: "volume_snapshot";
};
export type TagsResourceResourcesInnerResourceTypeEnum = (typeof TagsResourceResourcesInnerResourceTypeEnum)[keyof typeof TagsResourceResourcesInnerResourceTypeEnum];
export interface TagsResources {
    count?: number;
    last_tagged_uri?: string;
    droplets?: TagsMetadata;
    imgages?: TagsMetadata;
    volumes?: TagsMetadata;
    volume_snapshots?: TagsMetadata;
    databases?: TagsMetadata;
}
export interface TimescaledbAdvancedConfig {
    max_background_workers?: number;
}
export interface TriggerInfo {
    namespace?: string;
    name?: string;
    function?: string;
    type?: string;
    is_enabled?: boolean;
    created_at?: string;
    updated_at?: string;
    scheduled_details?: ScheduledDetails;
    scheduled_runs?: TriggerInfoScheduledRuns;
}
export interface TriggerInfoScheduledRuns {
    last_run_at?: string | null;
    next_run_at?: string | null;
}
export interface UpdateEndpoint {
    ttl?: UpdateEndpointTtlEnum;
    certificate_id?: string;
    custom_domain?: string;
}
export declare const UpdateEndpointTtlEnum: {
    readonly NUMBER_60: 60;
    readonly NUMBER_600: 600;
    readonly NUMBER_3600: 3600;
    readonly NUMBER_86400: 86400;
    readonly NUMBER_604800: 604800;
};
export type UpdateEndpointTtlEnum = (typeof UpdateEndpointTtlEnum)[keyof typeof UpdateEndpointTtlEnum];
export interface UpdateRegistry {
    cancel?: boolean;
}
export interface UpdateTrigger {
    is_enabled?: boolean;
    scheduled_details?: ScheduledDetails;
}
export interface UptimeCreateAlert201Response {
    alert?: Alert;
}
export interface UptimeCreateCheck201Response {
    check?: Check;
}
export interface UptimeGetCheckState200Response {
    state?: State;
}
export interface UptimeListAlerts200Response {
    links?: PageLinks;
    meta: MetaMeta;
    alerts?: Array<Alert>;
}
export interface UptimeListChecks200Response {
    links?: PageLinks;
    meta: MetaMeta;
    checks?: Array<Check>;
}
export interface User {
    kubernetes_cluster_user?: UserKubernetesClusterUser;
}
export interface UserKubernetesClusterUser {
    username?: string;
    groups?: Array<string>;
}
export interface UserSettings {
    pg_allow_replication?: boolean;
    opensearch_acl?: Array<UserSettingsOpensearchAclInner>;
    acl?: Array<UserSettingsAclInner>;
}
export interface UserSettingsAclInner {
    id?: string;
    topic: string;
    permission: UserSettingsAclInnerPermissionEnum;
}
export declare const UserSettingsAclInnerPermissionEnum: {
    readonly Admin: "admin";
    readonly Consume: "consume";
    readonly Produce: "produce";
    readonly Produceconsume: "produceconsume";
};
export type UserSettingsAclInnerPermissionEnum = (typeof UserSettingsAclInnerPermissionEnum)[keyof typeof UserSettingsAclInnerPermissionEnum];
export interface UserSettingsOpensearchAclInner {
    index?: string;
    permission?: UserSettingsOpensearchAclInnerPermissionEnum;
}
export declare const UserSettingsOpensearchAclInnerPermissionEnum: {
    readonly Deny: "deny";
    readonly Admin: "admin";
    readonly Read: "read";
    readonly Readwrite: "readwrite";
    readonly Write: "write";
};
export type UserSettingsOpensearchAclInnerPermissionEnum = (typeof UserSettingsOpensearchAclInnerPermissionEnum)[keyof typeof UserSettingsOpensearchAclInnerPermissionEnum];
export interface ValidateRegistry {
    name: string;
}
export interface Version2 {
    version?: string;
}
export interface VolumeAction {
    id?: number;
    status?: VolumeActionStatusEnum;
    type?: string;
    started_at?: string;
    completed_at?: string | null;
    resource_id?: number | null;
    resource_type?: string;
    region?: Region;
    region_slug?: string;
}
export declare const VolumeActionStatusEnum: {
    readonly InProgress: "in-progress";
    readonly Completed: "completed";
    readonly Errored: "errored";
};
export type VolumeActionStatusEnum = (typeof VolumeActionStatusEnum)[keyof typeof VolumeActionStatusEnum];
export interface VolumeActionPostAttach {
    type: VolumeActionPostAttachTypeEnum;
    region?: RegionSlug;
    droplet_id: number;
    tags?: Array<string> | null;
}
export declare const VolumeActionPostAttachTypeEnum: {
    readonly Attach: "attach";
    readonly Detach: "detach";
    readonly Resize: "resize";
};
export type VolumeActionPostAttachTypeEnum = (typeof VolumeActionPostAttachTypeEnum)[keyof typeof VolumeActionPostAttachTypeEnum];
export interface VolumeActionPostBase {
    type: VolumeActionPostBaseTypeEnum;
    region?: RegionSlug;
}
export declare const VolumeActionPostBaseTypeEnum: {
    readonly Attach: "attach";
    readonly Detach: "detach";
    readonly Resize: "resize";
};
export type VolumeActionPostBaseTypeEnum = (typeof VolumeActionPostBaseTypeEnum)[keyof typeof VolumeActionPostBaseTypeEnum];
export interface VolumeActionPostDetach {
    type: VolumeActionPostDetachTypeEnum;
    region?: RegionSlug;
    droplet_id: number;
}
export declare const VolumeActionPostDetachTypeEnum: {
    readonly Attach: "attach";
    readonly Detach: "detach";
    readonly Resize: "resize";
};
export type VolumeActionPostDetachTypeEnum = (typeof VolumeActionPostDetachTypeEnum)[keyof typeof VolumeActionPostDetachTypeEnum];
export interface VolumeActionPostResize {
    type: VolumeActionPostResizeTypeEnum;
    region?: RegionSlug;
    size_gigabytes: number;
}
export declare const VolumeActionPostResizeTypeEnum: {
    readonly Attach: "attach";
    readonly Detach: "detach";
    readonly Resize: "resize";
};
export type VolumeActionPostResizeTypeEnum = (typeof VolumeActionPostResizeTypeEnum)[keyof typeof VolumeActionPostResizeTypeEnum];
export interface VolumeActionsList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    actions?: Array<VolumeAction>;
}
export interface VolumeActionsPost202Response {
    action?: VolumeAction;
}
export interface VolumeActionsPostByIdRequest {
    type: VolumeActionsPostByIdRequestTypeEnum;
    region?: RegionSlug;
    droplet_id: number;
    tags?: Array<string> | null;
    size_gigabytes: number;
}
export declare const VolumeActionsPostByIdRequestTypeEnum: {
    readonly Attach: "attach";
    readonly Detach: "detach";
    readonly Resize: "resize";
};
export type VolumeActionsPostByIdRequestTypeEnum = (typeof VolumeActionsPostByIdRequestTypeEnum)[keyof typeof VolumeActionsPostByIdRequestTypeEnum];
export interface VolumeActionsPostRequest {
    type: VolumeActionsPostRequestTypeEnum;
    region?: RegionSlug;
    droplet_id: number;
    tags?: Array<string> | null;
}
export declare const VolumeActionsPostRequestTypeEnum: {
    readonly Attach: "attach";
    readonly Detach: "detach";
    readonly Resize: "resize";
};
export type VolumeActionsPostRequestTypeEnum = (typeof VolumeActionsPostRequestTypeEnum)[keyof typeof VolumeActionsPostRequestTypeEnum];
export interface VolumeBase {
    id?: string;
    droplet_ids?: Array<number> | null;
    name?: string;
    description?: string;
    size_gigabytes?: number;
    created_at?: string;
    tags?: Array<string> | null;
}
export interface VolumeFull {
    id?: string;
    droplet_ids?: Array<number> | null;
    name?: string;
    description?: string;
    size_gigabytes?: number;
    created_at?: string;
    tags?: Array<string> | null;
    region?: VolumeFullAllOfRegion;
    filesystem_type?: string;
    filesystem_label?: string;
}
export interface VolumeFullAllOfRegion {
    name: string;
    slug: string;
    features: Array<string>;
    available: boolean;
    sizes: Array<string>;
}
export interface VolumeSnapshotId {
    snapshot_id?: string;
}
export interface VolumeSnapshotsCreateRequest {
    name: string;
    tags?: Array<string> | null;
}
export interface VolumeSnapshotsGetById200Response {
    snapshot?: Snapshots;
}
export interface VolumeSnapshotsList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    snapshots?: Array<Snapshots>;
}
export interface VolumeWriteFileSystemType {
    filesystem_type?: string;
}
export interface VolumesCreate201Response {
    volume?: VolumeFull;
}
export interface VolumesCreateRequest {
    id?: string;
    droplet_ids?: Array<number> | null;
    name: string;
    description?: string;
    size_gigabytes: number;
    created_at?: string;
    tags?: Array<string> | null;
    snapshot_id?: string;
    filesystem_type?: string;
    region: RegionSlug;
    filesystem_label?: VolumesXfsAllOfFilesystemLabel;
}
export interface VolumesExt4 {
    id?: string;
    droplet_ids?: Array<number> | null;
    name: string;
    description?: string;
    size_gigabytes: number;
    created_at?: string;
    tags?: Array<string> | null;
    snapshot_id?: string;
    filesystem_type?: string;
    region: RegionSlug;
    filesystem_label?: VolumesExt4AllOfFilesystemLabel;
}
export type VolumesExt4AllOfFilesystemLabel = {};
export interface VolumesList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    volumes: Array<VolumeFull>;
}
export interface VolumesXfs {
    id?: string;
    droplet_ids?: Array<number> | null;
    name: string;
    description?: string;
    size_gigabytes: number;
    created_at?: string;
    tags?: Array<string> | null;
    snapshot_id?: string;
    filesystem_type?: string;
    region: RegionSlug;
    filesystem_label?: VolumesXfsAllOfFilesystemLabel;
}
export type VolumesXfsAllOfFilesystemLabel = {};
export interface Vpc {
    name?: string;
    description?: string;
    region?: string;
    ip_range?: string;
    default?: boolean;
    id?: string;
    urn?: string;
    created_at?: string;
}
export interface VpcBase {
    id?: string;
    urn?: string;
    created_at?: string;
}
export interface VpcCreate {
    region?: string;
    ip_range?: string;
}
export interface VpcDefault {
    default?: boolean;
}
export interface VpcMember {
    name?: string;
    urn?: string;
    created_at?: string;
}
export interface VpcUpdatable {
    name?: string;
    description?: string;
}
export interface VpcsCreate201Response {
    vpc?: Vpc;
}
export interface VpcsCreateRequest {
    name: string;
    description?: string;
    region: string;
    ip_range?: string;
}
export interface VpcsList200Response {
    links?: PageLinks;
    meta: MetaMeta;
    vpcs?: Array<Vpc>;
}
export interface VpcsListMembers200Response {
    links?: PageLinks;
    meta: MetaMeta;
    members?: Array<VpcMember>;
}
export interface VpcsPatchRequest {
    name?: string;
    description?: string;
    default?: boolean;
}
export interface VpcsUpdateRequest {
    name: string;
    description?: string;
    default?: boolean;
}
export declare const AccountApiAxiosParamCreator: (configuration?: Configuration) => {
    accountGet: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const AccountApiFp: (configuration?: Configuration) => {
    accountGet(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AccountGet200Response>>;
};
export declare const AccountApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    accountGet(options?: RawAxiosRequestConfig): AxiosPromise<AccountGet200Response>;
};
export declare class AccountApi extends BaseAPI {
    accountGet(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AccountGet200Response, any>>;
}
export declare const ActionsApiAxiosParamCreator: (configuration?: Configuration) => {
    actionsGet: (actionId: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    actionsList: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const ActionsApiFp: (configuration?: Configuration) => {
    actionsGet(actionId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ActionsGet200Response>>;
    actionsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ActionsList200Response>>;
};
export declare const ActionsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    actionsGet(actionId: number, options?: RawAxiosRequestConfig): AxiosPromise<ActionsGet200Response>;
    actionsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<ActionsList200Response>;
};
export declare class ActionsApi extends BaseAPI {
    actionsGet(actionId: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ActionsGet200Response, any>>;
    actionsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ActionsList200Response, any>>;
}
export declare const AppsApiAxiosParamCreator: (configuration?: Configuration) => {
    appsAssignAlertDestinations: (appId: string, alertId: string, appsAssignAppAlertDestinationsRequest: AppsAssignAppAlertDestinationsRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsCancelDeployment: (appId: string, deploymentId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsCommitRollback: (appId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsCreate: (appsCreateAppRequest: AppsCreateAppRequest, accept?: AppsCreateAcceptEnum, contentType?: AppsCreateContentTypeEnum, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsCreateDeployment: (appId: string, appsCreateDeploymentRequest: AppsCreateDeploymentRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsCreateRollback: (appId: string, appsRollbackAppRequest: AppsRollbackAppRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsDelete: (id: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsGet: (id: string, name?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsGetDeployment: (appId: string, deploymentId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsGetInstanceSize: (slug: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsGetLogs: (appId: string, deploymentId: string, componentName: string, type: AppsGetLogsTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsGetLogsActiveDeployment: (appId: string, componentName: string, type: AppsGetLogsActiveDeploymentTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsGetLogsActiveDeploymentAggregate: (appId: string, type: AppsGetLogsActiveDeploymentAggregateTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsGetLogsAggregate: (appId: string, deploymentId: string, type: AppsGetLogsAggregateTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsGetMetricsBandwidthDaily: (appId: string, date?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsList: (page?: number, perPage?: number, withProjects?: boolean, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsListAlerts: (appId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsListDeployments: (appId: string, page?: number, perPage?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsListInstanceSizes: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsListMetricsBandwidthDaily: (appMetricsBandwidthUsageRequest: AppMetricsBandwidthUsageRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsListRegions: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsRevertRollback: (appId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsUpdate: (id: string, appsUpdateAppRequest: AppsUpdateAppRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsValidateAppSpec: (appPropose: AppPropose, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    appsValidateRollback: (appId: string, appsRollbackAppRequest: AppsRollbackAppRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const AppsApiFp: (configuration?: Configuration) => {
    appsAssignAlertDestinations(appId: string, alertId: string, appsAssignAppAlertDestinationsRequest: AppsAssignAppAlertDestinationsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsAlertResponse>>;
    appsCancelDeployment(appId: string, deploymentId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsDeploymentResponse>>;
    appsCommitRollback(appId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    appsCreate(appsCreateAppRequest: AppsCreateAppRequest, accept?: AppsCreateAcceptEnum, contentType?: AppsCreateContentTypeEnum, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppResponse>>;
    appsCreateDeployment(appId: string, appsCreateDeploymentRequest: AppsCreateDeploymentRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsDeploymentResponse>>;
    appsCreateRollback(appId: string, appsRollbackAppRequest: AppsRollbackAppRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsDeploymentResponse>>;
    appsDelete(id: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsDeleteAppResponse>>;
    appsGet(id: string, name?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppResponse>>;
    appsGetDeployment(appId: string, deploymentId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsDeploymentResponse>>;
    appsGetInstanceSize(slug: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsGetInstanceSizeResponse>>;
    appsGetLogs(appId: string, deploymentId: string, componentName: string, type: AppsGetLogsTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsGetLogsResponse>>;
    appsGetLogsActiveDeployment(appId: string, componentName: string, type: AppsGetLogsActiveDeploymentTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsGetLogsResponse>>;
    appsGetLogsActiveDeploymentAggregate(appId: string, type: AppsGetLogsActiveDeploymentAggregateTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsGetLogsResponse>>;
    appsGetLogsAggregate(appId: string, deploymentId: string, type: AppsGetLogsAggregateTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsGetLogsResponse>>;
    appsGetMetricsBandwidthDaily(appId: string, date?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppMetricsBandwidthUsage>>;
    appsList(page?: number, perPage?: number, withProjects?: boolean, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsResponse>>;
    appsListAlerts(appId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsListAlertsResponse>>;
    appsListDeployments(appId: string, page?: number, perPage?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsDeploymentsResponse>>;
    appsListInstanceSizes(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsListInstanceSizesResponse>>;
    appsListMetricsBandwidthDaily(appMetricsBandwidthUsageRequest: AppMetricsBandwidthUsageRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppMetricsBandwidthUsage>>;
    appsListRegions(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsListRegionsResponse>>;
    appsRevertRollback(appId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsDeploymentResponse>>;
    appsUpdate(id: string, appsUpdateAppRequest: AppsUpdateAppRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppResponse>>;
    appsValidateAppSpec(appPropose: AppPropose, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppProposeResponse>>;
    appsValidateRollback(appId: string, appsRollbackAppRequest: AppsRollbackAppRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AppsValidateRollback200Response>>;
};
export declare const AppsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    appsAssignAlertDestinations(appId: string, alertId: string, appsAssignAppAlertDestinationsRequest: AppsAssignAppAlertDestinationsRequest, options?: RawAxiosRequestConfig): AxiosPromise<AppsAlertResponse>;
    appsCancelDeployment(appId: string, deploymentId: string, options?: RawAxiosRequestConfig): AxiosPromise<AppsDeploymentResponse>;
    appsCommitRollback(appId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    appsCreate(appsCreateAppRequest: AppsCreateAppRequest, accept?: AppsCreateAcceptEnum, contentType?: AppsCreateContentTypeEnum, options?: RawAxiosRequestConfig): AxiosPromise<AppResponse>;
    appsCreateDeployment(appId: string, appsCreateDeploymentRequest: AppsCreateDeploymentRequest, options?: RawAxiosRequestConfig): AxiosPromise<AppsDeploymentResponse>;
    appsCreateRollback(appId: string, appsRollbackAppRequest: AppsRollbackAppRequest, options?: RawAxiosRequestConfig): AxiosPromise<AppsDeploymentResponse>;
    appsDelete(id: string, options?: RawAxiosRequestConfig): AxiosPromise<AppsDeleteAppResponse>;
    appsGet(id: string, name?: string, options?: RawAxiosRequestConfig): AxiosPromise<AppResponse>;
    appsGetDeployment(appId: string, deploymentId: string, options?: RawAxiosRequestConfig): AxiosPromise<AppsDeploymentResponse>;
    appsGetInstanceSize(slug: string, options?: RawAxiosRequestConfig): AxiosPromise<AppsGetInstanceSizeResponse>;
    appsGetLogs(appId: string, deploymentId: string, componentName: string, type: AppsGetLogsTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig): AxiosPromise<AppsGetLogsResponse>;
    appsGetLogsActiveDeployment(appId: string, componentName: string, type: AppsGetLogsActiveDeploymentTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig): AxiosPromise<AppsGetLogsResponse>;
    appsGetLogsActiveDeploymentAggregate(appId: string, type: AppsGetLogsActiveDeploymentAggregateTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig): AxiosPromise<AppsGetLogsResponse>;
    appsGetLogsAggregate(appId: string, deploymentId: string, type: AppsGetLogsAggregateTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig): AxiosPromise<AppsGetLogsResponse>;
    appsGetMetricsBandwidthDaily(appId: string, date?: string, options?: RawAxiosRequestConfig): AxiosPromise<AppMetricsBandwidthUsage>;
    appsList(page?: number, perPage?: number, withProjects?: boolean, options?: RawAxiosRequestConfig): AxiosPromise<AppsResponse>;
    appsListAlerts(appId: string, options?: RawAxiosRequestConfig): AxiosPromise<AppsListAlertsResponse>;
    appsListDeployments(appId: string, page?: number, perPage?: number, options?: RawAxiosRequestConfig): AxiosPromise<AppsDeploymentsResponse>;
    appsListInstanceSizes(options?: RawAxiosRequestConfig): AxiosPromise<AppsListInstanceSizesResponse>;
    appsListMetricsBandwidthDaily(appMetricsBandwidthUsageRequest: AppMetricsBandwidthUsageRequest, options?: RawAxiosRequestConfig): AxiosPromise<AppMetricsBandwidthUsage>;
    appsListRegions(options?: RawAxiosRequestConfig): AxiosPromise<AppsListRegionsResponse>;
    appsRevertRollback(appId: string, options?: RawAxiosRequestConfig): AxiosPromise<AppsDeploymentResponse>;
    appsUpdate(id: string, appsUpdateAppRequest: AppsUpdateAppRequest, options?: RawAxiosRequestConfig): AxiosPromise<AppResponse>;
    appsValidateAppSpec(appPropose: AppPropose, options?: RawAxiosRequestConfig): AxiosPromise<AppProposeResponse>;
    appsValidateRollback(appId: string, appsRollbackAppRequest: AppsRollbackAppRequest, options?: RawAxiosRequestConfig): AxiosPromise<AppsValidateRollback200Response>;
};
export declare class AppsApi extends BaseAPI {
    appsAssignAlertDestinations(appId: string, alertId: string, appsAssignAppAlertDestinationsRequest: AppsAssignAppAlertDestinationsRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsAlertResponse, any>>;
    appsCancelDeployment(appId: string, deploymentId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsDeploymentResponse, any>>;
    appsCommitRollback(appId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    appsCreate(appsCreateAppRequest: AppsCreateAppRequest, accept?: AppsCreateAcceptEnum, contentType?: AppsCreateContentTypeEnum, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppResponse, any>>;
    appsCreateDeployment(appId: string, appsCreateDeploymentRequest: AppsCreateDeploymentRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsDeploymentResponse, any>>;
    appsCreateRollback(appId: string, appsRollbackAppRequest: AppsRollbackAppRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsDeploymentResponse, any>>;
    appsDelete(id: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsDeleteAppResponse, any>>;
    appsGet(id: string, name?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppResponse, any>>;
    appsGetDeployment(appId: string, deploymentId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsDeploymentResponse, any>>;
    appsGetInstanceSize(slug: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsGetInstanceSizeResponse, any>>;
    appsGetLogs(appId: string, deploymentId: string, componentName: string, type: AppsGetLogsTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsGetLogsResponse, any>>;
    appsGetLogsActiveDeployment(appId: string, componentName: string, type: AppsGetLogsActiveDeploymentTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsGetLogsResponse, any>>;
    appsGetLogsActiveDeploymentAggregate(appId: string, type: AppsGetLogsActiveDeploymentAggregateTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsGetLogsResponse, any>>;
    appsGetLogsAggregate(appId: string, deploymentId: string, type: AppsGetLogsAggregateTypeEnum, follow?: boolean, podConnectionTimeout?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsGetLogsResponse, any>>;
    appsGetMetricsBandwidthDaily(appId: string, date?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppMetricsBandwidthUsage, any>>;
    appsList(page?: number, perPage?: number, withProjects?: boolean, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsResponse, any>>;
    appsListAlerts(appId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsListAlertsResponse, any>>;
    appsListDeployments(appId: string, page?: number, perPage?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsDeploymentsResponse, any>>;
    appsListInstanceSizes(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsListInstanceSizesResponse, any>>;
    appsListMetricsBandwidthDaily(appMetricsBandwidthUsageRequest: AppMetricsBandwidthUsageRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppMetricsBandwidthUsage, any>>;
    appsListRegions(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsListRegionsResponse, any>>;
    appsRevertRollback(appId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsDeploymentResponse, any>>;
    appsUpdate(id: string, appsUpdateAppRequest: AppsUpdateAppRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppResponse, any>>;
    appsValidateAppSpec(appPropose: AppPropose, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppProposeResponse, any>>;
    appsValidateRollback(appId: string, appsRollbackAppRequest: AppsRollbackAppRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AppsValidateRollback200Response, any>>;
}
export declare const AppsCreateAcceptEnum: {
    readonly Json: "application/json";
    readonly Yaml: "application/yaml";
};
export type AppsCreateAcceptEnum = (typeof AppsCreateAcceptEnum)[keyof typeof AppsCreateAcceptEnum];
export declare const AppsCreateContentTypeEnum: {
    readonly Json: "application/json";
    readonly Yaml: "application/yaml";
};
export type AppsCreateContentTypeEnum = (typeof AppsCreateContentTypeEnum)[keyof typeof AppsCreateContentTypeEnum];
export declare const AppsGetLogsTypeEnum: {
    readonly Unspecified: "UNSPECIFIED";
    readonly Build: "BUILD";
    readonly Deploy: "DEPLOY";
    readonly Run: "RUN";
    readonly RunRestarted: "RUN_RESTARTED";
};
export type AppsGetLogsTypeEnum = (typeof AppsGetLogsTypeEnum)[keyof typeof AppsGetLogsTypeEnum];
export declare const AppsGetLogsActiveDeploymentTypeEnum: {
    readonly Unspecified: "UNSPECIFIED";
    readonly Build: "BUILD";
    readonly Deploy: "DEPLOY";
    readonly Run: "RUN";
    readonly RunRestarted: "RUN_RESTARTED";
};
export type AppsGetLogsActiveDeploymentTypeEnum = (typeof AppsGetLogsActiveDeploymentTypeEnum)[keyof typeof AppsGetLogsActiveDeploymentTypeEnum];
export declare const AppsGetLogsActiveDeploymentAggregateTypeEnum: {
    readonly Unspecified: "UNSPECIFIED";
    readonly Build: "BUILD";
    readonly Deploy: "DEPLOY";
    readonly Run: "RUN";
    readonly RunRestarted: "RUN_RESTARTED";
};
export type AppsGetLogsActiveDeploymentAggregateTypeEnum = (typeof AppsGetLogsActiveDeploymentAggregateTypeEnum)[keyof typeof AppsGetLogsActiveDeploymentAggregateTypeEnum];
export declare const AppsGetLogsAggregateTypeEnum: {
    readonly Unspecified: "UNSPECIFIED";
    readonly Build: "BUILD";
    readonly Deploy: "DEPLOY";
    readonly Run: "RUN";
    readonly RunRestarted: "RUN_RESTARTED";
};
export type AppsGetLogsAggregateTypeEnum = (typeof AppsGetLogsAggregateTypeEnum)[keyof typeof AppsGetLogsAggregateTypeEnum];
export declare const BillingApiAxiosParamCreator: (configuration?: Configuration) => {
    balanceGet: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    billingHistoryList: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    invoicesGetByUUID: (invoiceUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    invoicesGetCsvByUUID: (invoiceUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    invoicesGetPdfByUUID: (invoiceUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    invoicesGetSummaryByUUID: (invoiceUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    invoicesList: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const BillingApiFp: (configuration?: Configuration) => {
    balanceGet(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Balance>>;
    billingHistoryList(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<BillingHistoryList200Response>>;
    invoicesGetByUUID(invoiceUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<InvoicesGetByUUID200Response>>;
    invoicesGetCsvByUUID(invoiceUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<string>>;
    invoicesGetPdfByUUID(invoiceUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<File>>;
    invoicesGetSummaryByUUID(invoiceUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<InvoiceSummary>>;
    invoicesList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<InvoicesList200Response>>;
};
export declare const BillingApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    balanceGet(options?: RawAxiosRequestConfig): AxiosPromise<Balance>;
    billingHistoryList(options?: RawAxiosRequestConfig): AxiosPromise<BillingHistoryList200Response>;
    invoicesGetByUUID(invoiceUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<InvoicesGetByUUID200Response>;
    invoicesGetCsvByUUID(invoiceUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<string>;
    invoicesGetPdfByUUID(invoiceUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<File>;
    invoicesGetSummaryByUUID(invoiceUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<InvoiceSummary>;
    invoicesList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<InvoicesList200Response>;
};
export declare class BillingApi extends BaseAPI {
    balanceGet(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Balance, any>>;
    billingHistoryList(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<BillingHistoryList200Response, any>>;
    invoicesGetByUUID(invoiceUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<InvoicesGetByUUID200Response, any>>;
    invoicesGetCsvByUUID(invoiceUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<string, any>>;
    invoicesGetPdfByUUID(invoiceUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<File, any>>;
    invoicesGetSummaryByUUID(invoiceUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<InvoiceSummary, any>>;
    invoicesList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<InvoicesList200Response, any>>;
}
export declare const BlockStorageApiAxiosParamCreator: (configuration?: Configuration) => {
    volumeSnapshotsCreate: (volumeId: string, volumeSnapshotsCreateRequest: VolumeSnapshotsCreateRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    volumeSnapshotsDeleteById: (snapshotId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    volumeSnapshotsGetById: (snapshotId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    volumeSnapshotsList: (volumeId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    volumesCreate: (volumesCreateRequest: VolumesCreateRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    volumesDelete: (volumeId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    volumesDeleteByName: (name?: string, region?: RegionSlug, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    volumesGet: (volumeId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    volumesList: (name?: string, region?: RegionSlug, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const BlockStorageApiFp: (configuration?: Configuration) => {
    volumeSnapshotsCreate(volumeId: string, volumeSnapshotsCreateRequest: VolumeSnapshotsCreateRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VolumeSnapshotsGetById200Response>>;
    volumeSnapshotsDeleteById(snapshotId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    volumeSnapshotsGetById(snapshotId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VolumeSnapshotsGetById200Response>>;
    volumeSnapshotsList(volumeId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VolumeSnapshotsList200Response>>;
    volumesCreate(volumesCreateRequest: VolumesCreateRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VolumesCreate201Response>>;
    volumesDelete(volumeId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    volumesDeleteByName(name?: string, region?: RegionSlug, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    volumesGet(volumeId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VolumesCreate201Response>>;
    volumesList(name?: string, region?: RegionSlug, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VolumesList200Response>>;
};
export declare const BlockStorageApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    volumeSnapshotsCreate(volumeId: string, volumeSnapshotsCreateRequest: VolumeSnapshotsCreateRequest, options?: RawAxiosRequestConfig): AxiosPromise<VolumeSnapshotsGetById200Response>;
    volumeSnapshotsDeleteById(snapshotId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    volumeSnapshotsGetById(snapshotId: string, options?: RawAxiosRequestConfig): AxiosPromise<VolumeSnapshotsGetById200Response>;
    volumeSnapshotsList(volumeId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<VolumeSnapshotsList200Response>;
    volumesCreate(volumesCreateRequest: VolumesCreateRequest, options?: RawAxiosRequestConfig): AxiosPromise<VolumesCreate201Response>;
    volumesDelete(volumeId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    volumesDeleteByName(name?: string, region?: RegionSlug, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    volumesGet(volumeId: string, options?: RawAxiosRequestConfig): AxiosPromise<VolumesCreate201Response>;
    volumesList(name?: string, region?: RegionSlug, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<VolumesList200Response>;
};
export declare class BlockStorageApi extends BaseAPI {
    volumeSnapshotsCreate(volumeId: string, volumeSnapshotsCreateRequest: VolumeSnapshotsCreateRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VolumeSnapshotsGetById200Response, any>>;
    volumeSnapshotsDeleteById(snapshotId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    volumeSnapshotsGetById(snapshotId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VolumeSnapshotsGetById200Response, any>>;
    volumeSnapshotsList(volumeId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VolumeSnapshotsList200Response, any>>;
    volumesCreate(volumesCreateRequest: VolumesCreateRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VolumesCreate201Response, any>>;
    volumesDelete(volumeId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    volumesDeleteByName(name?: string, region?: RegionSlug, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    volumesGet(volumeId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VolumesCreate201Response, any>>;
    volumesList(name?: string, region?: RegionSlug, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VolumesList200Response, any>>;
}
export declare const BlockStorageActionsApiAxiosParamCreator: (configuration?: Configuration) => {
    volumeActionsGet: (volumeId: string, actionId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    volumeActionsList: (volumeId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    volumeActionsPost: (volumeActionsPostRequest: VolumeActionsPostRequest, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    volumeActionsPostById: (volumeId: string, volumeActionsPostByIdRequest: VolumeActionsPostByIdRequest, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const BlockStorageActionsApiFp: (configuration?: Configuration) => {
    volumeActionsGet(volumeId: string, actionId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VolumeActionsPost202Response>>;
    volumeActionsList(volumeId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VolumeActionsList200Response>>;
    volumeActionsPost(volumeActionsPostRequest: VolumeActionsPostRequest, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VolumeActionsPost202Response>>;
    volumeActionsPostById(volumeId: string, volumeActionsPostByIdRequest: VolumeActionsPostByIdRequest, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VolumeActionsPost202Response>>;
};
export declare const BlockStorageActionsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    volumeActionsGet(volumeId: string, actionId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<VolumeActionsPost202Response>;
    volumeActionsList(volumeId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<VolumeActionsList200Response>;
    volumeActionsPost(volumeActionsPostRequest: VolumeActionsPostRequest, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<VolumeActionsPost202Response>;
    volumeActionsPostById(volumeId: string, volumeActionsPostByIdRequest: VolumeActionsPostByIdRequest, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<VolumeActionsPost202Response>;
};
export declare class BlockStorageActionsApi extends BaseAPI {
    volumeActionsGet(volumeId: string, actionId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VolumeActionsPost202Response, any>>;
    volumeActionsList(volumeId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VolumeActionsList200Response, any>>;
    volumeActionsPost(volumeActionsPostRequest: VolumeActionsPostRequest, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VolumeActionsPost202Response, any>>;
    volumeActionsPostById(volumeId: string, volumeActionsPostByIdRequest: VolumeActionsPostByIdRequest, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VolumeActionsPost202Response, any>>;
}
export declare const CDNEndpointsApiAxiosParamCreator: (configuration?: Configuration) => {
    cdnCreateEndpoint: (cdnEndpoint: CdnEndpoint, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    cdnDeleteEndpoint: (cdnId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    cdnGetEndpoint: (cdnId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    cdnListEndpoints: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    cdnPurgeCache: (cdnId: string, purgeCache: PurgeCache, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    cdnUpdateEndpoints: (cdnId: string, updateEndpoint: UpdateEndpoint, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const CDNEndpointsApiFp: (configuration?: Configuration) => {
    cdnCreateEndpoint(cdnEndpoint: CdnEndpoint, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CdnCreateEndpoint201Response>>;
    cdnDeleteEndpoint(cdnId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    cdnGetEndpoint(cdnId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CdnCreateEndpoint201Response>>;
    cdnListEndpoints(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CdnListEndpoints200Response>>;
    cdnPurgeCache(cdnId: string, purgeCache: PurgeCache, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    cdnUpdateEndpoints(cdnId: string, updateEndpoint: UpdateEndpoint, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CdnCreateEndpoint201Response>>;
};
export declare const CDNEndpointsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    cdnCreateEndpoint(cdnEndpoint: CdnEndpoint, options?: RawAxiosRequestConfig): AxiosPromise<CdnCreateEndpoint201Response>;
    cdnDeleteEndpoint(cdnId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    cdnGetEndpoint(cdnId: string, options?: RawAxiosRequestConfig): AxiosPromise<CdnCreateEndpoint201Response>;
    cdnListEndpoints(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<CdnListEndpoints200Response>;
    cdnPurgeCache(cdnId: string, purgeCache: PurgeCache, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    cdnUpdateEndpoints(cdnId: string, updateEndpoint: UpdateEndpoint, options?: RawAxiosRequestConfig): AxiosPromise<CdnCreateEndpoint201Response>;
};
export declare class CDNEndpointsApi extends BaseAPI {
    cdnCreateEndpoint(cdnEndpoint: CdnEndpoint, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<CdnCreateEndpoint201Response, any>>;
    cdnDeleteEndpoint(cdnId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    cdnGetEndpoint(cdnId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<CdnCreateEndpoint201Response, any>>;
    cdnListEndpoints(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<CdnListEndpoints200Response, any>>;
    cdnPurgeCache(cdnId: string, purgeCache: PurgeCache, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    cdnUpdateEndpoints(cdnId: string, updateEndpoint: UpdateEndpoint, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<CdnCreateEndpoint201Response, any>>;
}
export declare const CertificatesApiAxiosParamCreator: (configuration?: Configuration) => {
    certificatesCreate: (certificatesCreateRequest: CertificatesCreateRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    certificatesDelete: (certificateId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    certificatesGet: (certificateId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    certificatesList: (perPage?: number, page?: number, name?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const CertificatesApiFp: (configuration?: Configuration) => {
    certificatesCreate(certificatesCreateRequest: CertificatesCreateRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CertificatesCreate201Response>>;
    certificatesDelete(certificateId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    certificatesGet(certificateId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CertificatesCreate201Response>>;
    certificatesList(perPage?: number, page?: number, name?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<CertificatesList200Response>>;
};
export declare const CertificatesApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    certificatesCreate(certificatesCreateRequest: CertificatesCreateRequest, options?: RawAxiosRequestConfig): AxiosPromise<CertificatesCreate201Response>;
    certificatesDelete(certificateId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    certificatesGet(certificateId: string, options?: RawAxiosRequestConfig): AxiosPromise<CertificatesCreate201Response>;
    certificatesList(perPage?: number, page?: number, name?: string, options?: RawAxiosRequestConfig): AxiosPromise<CertificatesList200Response>;
};
export declare class CertificatesApi extends BaseAPI {
    certificatesCreate(certificatesCreateRequest: CertificatesCreateRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<CertificatesCreate201Response, any>>;
    certificatesDelete(certificateId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    certificatesGet(certificateId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<CertificatesCreate201Response, any>>;
    certificatesList(perPage?: number, page?: number, name?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<CertificatesList200Response, any>>;
}
export declare const Class1ClickApplicationsApiAxiosParamCreator: (configuration?: Configuration) => {
    oneClicksInstallKubernetes: (oneClicksCreate: OneClicksCreate, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    oneClicksList: (type?: OneClicksListTypeEnum, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const Class1ClickApplicationsApiFp: (configuration?: Configuration) => {
    oneClicksInstallKubernetes(oneClicksCreate: OneClicksCreate, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<OneClicksInstallKubernetes200Response>>;
    oneClicksList(type?: OneClicksListTypeEnum, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<OneClicksList200Response>>;
};
export declare const Class1ClickApplicationsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    oneClicksInstallKubernetes(oneClicksCreate: OneClicksCreate, options?: RawAxiosRequestConfig): AxiosPromise<OneClicksInstallKubernetes200Response>;
    oneClicksList(type?: OneClicksListTypeEnum, options?: RawAxiosRequestConfig): AxiosPromise<OneClicksList200Response>;
};
export declare class Class1ClickApplicationsApi extends BaseAPI {
    oneClicksInstallKubernetes(oneClicksCreate: OneClicksCreate, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<OneClicksInstallKubernetes200Response, any>>;
    oneClicksList(type?: OneClicksListTypeEnum, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<OneClicksList200Response, any>>;
}
export declare const OneClicksListTypeEnum: {
    readonly Droplet: "droplet";
    readonly Kubernetes: "kubernetes";
};
export type OneClicksListTypeEnum = (typeof OneClicksListTypeEnum)[keyof typeof OneClicksListTypeEnum];
export declare const ContainerRegistryApiAxiosParamCreator: (configuration?: Configuration) => {
    registryCreate: (registryCreate: RegistryCreate, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryDelete: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryDeleteRepositoryManifest: (registryName: string, repositoryName: string, manifestDigest: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryDeleteRepositoryTag: (registryName: string, repositoryName: string, repositoryTag: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryGet: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryGetDockerCredentials: (expirySeconds?: number, readWrite?: boolean, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryGetGarbageCollection: (registryName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryGetOptions: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryGetSubscription: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryListGarbageCollections: (registryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryListRepositories: (registryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryListRepositoriesV2: (registryName: string, perPage?: number, page?: number, pageToken?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryListRepositoryManifests: (registryName: string, repositoryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryListRepositoryTags: (registryName: string, repositoryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryRunGarbageCollection: (registryName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryUpdateGarbageCollection: (registryName: string, garbageCollectionUuid: string, updateRegistry: UpdateRegistry, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryUpdateSubscription: (registryUpdateSubscriptionRequest?: RegistryUpdateSubscriptionRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    registryValidateName: (validateRegistry: ValidateRegistry, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const ContainerRegistryApiFp: (configuration?: Configuration) => {
    registryCreate(registryCreate: RegistryCreate, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RegistryGet200Response>>;
    registryDelete(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    registryDeleteRepositoryManifest(registryName: string, repositoryName: string, manifestDigest: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    registryDeleteRepositoryTag(registryName: string, repositoryName: string, repositoryTag: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    registryGet(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RegistryGet200Response>>;
    registryGetDockerCredentials(expirySeconds?: number, readWrite?: boolean, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DockerCredentials>>;
    registryGetGarbageCollection(registryName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RegistryGetGarbageCollection200Response>>;
    registryGetOptions(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RegistryGetOptions200Response>>;
    registryGetSubscription(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RegistryGetSubscription200Response>>;
    registryListGarbageCollections(registryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RegistryListGarbageCollections200Response>>;
    registryListRepositories(registryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RegistryListRepositories200Response>>;
    registryListRepositoriesV2(registryName: string, perPage?: number, page?: number, pageToken?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RegistryListRepositoriesV2200Response>>;
    registryListRepositoryManifests(registryName: string, repositoryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RegistryListRepositoryManifests200Response>>;
    registryListRepositoryTags(registryName: string, repositoryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RegistryListRepositoryTags200Response>>;
    registryRunGarbageCollection(registryName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RegistryGetGarbageCollection200Response>>;
    registryUpdateGarbageCollection(registryName: string, garbageCollectionUuid: string, updateRegistry: UpdateRegistry, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RegistryGetGarbageCollection200Response>>;
    registryUpdateSubscription(registryUpdateSubscriptionRequest?: RegistryUpdateSubscriptionRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RegistryGetSubscription200Response>>;
    registryValidateName(validateRegistry: ValidateRegistry, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
};
export declare const ContainerRegistryApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    registryCreate(registryCreate: RegistryCreate, options?: RawAxiosRequestConfig): AxiosPromise<RegistryGet200Response>;
    registryDelete(options?: RawAxiosRequestConfig): AxiosPromise<void>;
    registryDeleteRepositoryManifest(registryName: string, repositoryName: string, manifestDigest: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    registryDeleteRepositoryTag(registryName: string, repositoryName: string, repositoryTag: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    registryGet(options?: RawAxiosRequestConfig): AxiosPromise<RegistryGet200Response>;
    registryGetDockerCredentials(expirySeconds?: number, readWrite?: boolean, options?: RawAxiosRequestConfig): AxiosPromise<DockerCredentials>;
    registryGetGarbageCollection(registryName: string, options?: RawAxiosRequestConfig): AxiosPromise<RegistryGetGarbageCollection200Response>;
    registryGetOptions(options?: RawAxiosRequestConfig): AxiosPromise<RegistryGetOptions200Response>;
    registryGetSubscription(options?: RawAxiosRequestConfig): AxiosPromise<RegistryGetSubscription200Response>;
    registryListGarbageCollections(registryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<RegistryListGarbageCollections200Response>;
    registryListRepositories(registryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<RegistryListRepositories200Response>;
    registryListRepositoriesV2(registryName: string, perPage?: number, page?: number, pageToken?: string, options?: RawAxiosRequestConfig): AxiosPromise<RegistryListRepositoriesV2200Response>;
    registryListRepositoryManifests(registryName: string, repositoryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<RegistryListRepositoryManifests200Response>;
    registryListRepositoryTags(registryName: string, repositoryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<RegistryListRepositoryTags200Response>;
    registryRunGarbageCollection(registryName: string, options?: RawAxiosRequestConfig): AxiosPromise<RegistryGetGarbageCollection200Response>;
    registryUpdateGarbageCollection(registryName: string, garbageCollectionUuid: string, updateRegistry: UpdateRegistry, options?: RawAxiosRequestConfig): AxiosPromise<RegistryGetGarbageCollection200Response>;
    registryUpdateSubscription(registryUpdateSubscriptionRequest?: RegistryUpdateSubscriptionRequest, options?: RawAxiosRequestConfig): AxiosPromise<RegistryGetSubscription200Response>;
    registryValidateName(validateRegistry: ValidateRegistry, options?: RawAxiosRequestConfig): AxiosPromise<void>;
};
export declare class ContainerRegistryApi extends BaseAPI {
    registryCreate(registryCreate: RegistryCreate, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RegistryGet200Response, any>>;
    registryDelete(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    registryDeleteRepositoryManifest(registryName: string, repositoryName: string, manifestDigest: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    registryDeleteRepositoryTag(registryName: string, repositoryName: string, repositoryTag: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    registryGet(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RegistryGet200Response, any>>;
    registryGetDockerCredentials(expirySeconds?: number, readWrite?: boolean, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DockerCredentials, any>>;
    registryGetGarbageCollection(registryName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RegistryGetGarbageCollection200Response, any>>;
    registryGetOptions(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RegistryGetOptions200Response, any>>;
    registryGetSubscription(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RegistryGetSubscription200Response, any>>;
    registryListGarbageCollections(registryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RegistryListGarbageCollections200Response, any>>;
    registryListRepositories(registryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RegistryListRepositories200Response, any>>;
    registryListRepositoriesV2(registryName: string, perPage?: number, page?: number, pageToken?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RegistryListRepositoriesV2200Response, any>>;
    registryListRepositoryManifests(registryName: string, repositoryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RegistryListRepositoryManifests200Response, any>>;
    registryListRepositoryTags(registryName: string, repositoryName: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RegistryListRepositoryTags200Response, any>>;
    registryRunGarbageCollection(registryName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RegistryGetGarbageCollection200Response, any>>;
    registryUpdateGarbageCollection(registryName: string, garbageCollectionUuid: string, updateRegistry: UpdateRegistry, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RegistryGetGarbageCollection200Response, any>>;
    registryUpdateSubscription(registryUpdateSubscriptionRequest?: RegistryUpdateSubscriptionRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RegistryGetSubscription200Response, any>>;
    registryValidateName(validateRegistry: ValidateRegistry, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
}
export declare const DatabasesApiAxiosParamCreator: (configuration?: Configuration) => {
    databasesAdd: (databaseClusterUuid: string, database: Database, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesAddConnectionPool: (databaseClusterUuid: string, connectionPool: ConnectionPool, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesAddUser: (databaseClusterUuid: string, databasesAddUserRequest: DatabasesAddUserRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesCreateCluster: (databasesCreateClusterRequest: DatabasesCreateClusterRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesCreateKafkaTopic: (databaseClusterUuid: string, kafkaTopicCreate?: KafkaTopicCreate, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesCreateLogsink: (databaseClusterUuid: string, logsinkCreate: LogsinkCreate, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesCreateReplica: (databaseClusterUuid: string, databaseReplica?: DatabaseReplica, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesDelete: (databaseClusterUuid: string, databaseName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesDeleteConnectionPool: (databaseClusterUuid: string, poolName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesDeleteKafkaTopic: (databaseClusterUuid: string, topicName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesDeleteLogsink: (databaseClusterUuid: string, logsinkId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesDeleteOnlineMigration: (databaseClusterUuid: string, migrationId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesDeleteOpensearchIndex: (databaseClusterUuid: string, indexName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesDeleteUser: (databaseClusterUuid: string, username: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesDestroyCluster: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesDestroyReplica: (databaseClusterUuid: string, replicaName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesGet: (databaseClusterUuid: string, databaseName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesGetCa: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesGetCluster: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesGetClusterMetricsCredentials: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesGetConfig: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesGetConnectionPool: (databaseClusterUuid: string, poolName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesGetEvictionPolicy: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesGetKafkaTopic: (databaseClusterUuid: string, topicName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesGetLogsink: (databaseClusterUuid: string, logsinkId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesGetMigrationStatus: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesGetReplica: (databaseClusterUuid: string, replicaName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesGetSqlMode: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesGetUser: (databaseClusterUuid: string, username: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesList: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesListBackups: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesListClusters: (tagName?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesListConnectionPools: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesListEventsLogs: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesListFirewallRules: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesListKafkaTopics: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesListLogsink: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesListOpeasearchIndexes: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesListOptions: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesListReplicas: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesListUsers: (databaseClusterUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesPatchConfig: (databaseClusterUuid: string, databaseConfig: DatabaseConfig, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesPromoteReplica: (databaseClusterUuid: string, replicaName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesResetAuth: (databaseClusterUuid: string, username: string, databasesResetAuthRequest: DatabasesResetAuthRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesUpdateClusterMetricsCredentials: (databaseMetricsCredentials?: DatabaseMetricsCredentials, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesUpdateClusterSize: (databaseClusterUuid: string, databaseClusterResize: DatabaseClusterResize, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesUpdateConnectionPool: (databaseClusterUuid: string, poolName: string, connectionPoolUpdate: ConnectionPoolUpdate, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesUpdateEvictionPolicy: (databaseClusterUuid: string, databasesUpdateEvictionPolicyRequest: DatabasesUpdateEvictionPolicyRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesUpdateFirewallRules: (databaseClusterUuid: string, databasesUpdateFirewallRulesRequest: DatabasesUpdateFirewallRulesRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesUpdateKafkaTopic: (databaseClusterUuid: string, topicName: string, kafkaTopicUpdate?: KafkaTopicUpdate, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesUpdateLogsink: (databaseClusterUuid: string, logsinkId: string, logsinkUpdate: LogsinkUpdate, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesUpdateMaintenanceWindow: (databaseClusterUuid: string, databaseMaintenanceWindow: DatabaseMaintenanceWindow | null, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesUpdateMajorVersion: (databaseClusterUuid: string, version2: Version2, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesUpdateOnlineMigration: (databaseClusterUuid: string, sourceDatabase: SourceDatabase, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesUpdateRegion: (databaseClusterUuid: string, databasesUpdateRegionRequest: DatabasesUpdateRegionRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesUpdateSqlMode: (databaseClusterUuid: string, sqlMode: SqlMode, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    databasesUpdateUser: (databaseClusterUuid: string, username: string, databasesUpdateUserRequest: DatabasesUpdateUserRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const DatabasesApiFp: (configuration?: Configuration) => {
    databasesAdd(databaseClusterUuid: string, database: Database, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesAdd201Response>>;
    databasesAddConnectionPool(databaseClusterUuid: string, connectionPool: ConnectionPool, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesAddConnectionPool201Response>>;
    databasesAddUser(databaseClusterUuid: string, databasesAddUserRequest: DatabasesAddUserRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesAddUser201Response>>;
    databasesCreateCluster(databasesCreateClusterRequest: DatabasesCreateClusterRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesCreateCluster201Response>>;
    databasesCreateKafkaTopic(databaseClusterUuid: string, kafkaTopicCreate?: KafkaTopicCreate, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesCreateKafkaTopic201Response>>;
    databasesCreateLogsink(databaseClusterUuid: string, logsinkCreate: LogsinkCreate, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesCreateLogsink201Response>>;
    databasesCreateReplica(databaseClusterUuid: string, databaseReplica?: DatabaseReplica, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesCreateReplica201Response>>;
    databasesDelete(databaseClusterUuid: string, databaseName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesDeleteConnectionPool(databaseClusterUuid: string, poolName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesDeleteKafkaTopic(databaseClusterUuid: string, topicName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesDeleteLogsink(databaseClusterUuid: string, logsinkId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesDeleteOnlineMigration(databaseClusterUuid: string, migrationId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesDeleteOpensearchIndex(databaseClusterUuid: string, indexName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesDeleteUser(databaseClusterUuid: string, username: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesDestroyCluster(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesDestroyReplica(databaseClusterUuid: string, replicaName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesGet(databaseClusterUuid: string, databaseName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesAdd201Response>>;
    databasesGetCa(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesGetCa200Response>>;
    databasesGetCluster(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesCreateCluster201Response>>;
    databasesGetClusterMetricsCredentials(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesGetClusterMetricsCredentials200Response>>;
    databasesGetConfig(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesGetConfig200Response>>;
    databasesGetConnectionPool(databaseClusterUuid: string, poolName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesAddConnectionPool201Response>>;
    databasesGetEvictionPolicy(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesGetEvictionPolicy200Response>>;
    databasesGetKafkaTopic(databaseClusterUuid: string, topicName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesCreateKafkaTopic201Response>>;
    databasesGetLogsink(databaseClusterUuid: string, logsinkId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesCreateLogsink201Response>>;
    databasesGetMigrationStatus(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<OnlineMigration>>;
    databasesGetReplica(databaseClusterUuid: string, replicaName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesCreateReplica201Response>>;
    databasesGetSqlMode(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<SqlMode>>;
    databasesGetUser(databaseClusterUuid: string, username: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesAddUser201Response>>;
    databasesList(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesList200Response>>;
    databasesListBackups(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesListBackups200Response>>;
    databasesListClusters(tagName?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesListClusters200Response>>;
    databasesListConnectionPools(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ConnectionPools>>;
    databasesListEventsLogs(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesListEventsLogs200Response>>;
    databasesListFirewallRules(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesListFirewallRules200Response>>;
    databasesListKafkaTopics(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesListKafkaTopics200Response>>;
    databasesListLogsink(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesListLogsink201Response>>;
    databasesListOpeasearchIndexes(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesListOpeasearchIndexes200Response>>;
    databasesListOptions(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Options>>;
    databasesListReplicas(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesListReplicas200Response>>;
    databasesListUsers(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesListUsers200Response>>;
    databasesPatchConfig(databaseClusterUuid: string, databaseConfig: DatabaseConfig, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesPromoteReplica(databaseClusterUuid: string, replicaName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesResetAuth(databaseClusterUuid: string, username: string, databasesResetAuthRequest: DatabasesResetAuthRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesAddUser201Response>>;
    databasesUpdateClusterMetricsCredentials(databaseMetricsCredentials?: DatabaseMetricsCredentials, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesUpdateClusterSize(databaseClusterUuid: string, databaseClusterResize: DatabaseClusterResize, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesUpdateConnectionPool(databaseClusterUuid: string, poolName: string, connectionPoolUpdate: ConnectionPoolUpdate, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesUpdateEvictionPolicy(databaseClusterUuid: string, databasesUpdateEvictionPolicyRequest: DatabasesUpdateEvictionPolicyRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesUpdateFirewallRules(databaseClusterUuid: string, databasesUpdateFirewallRulesRequest: DatabasesUpdateFirewallRulesRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesUpdateKafkaTopic(databaseClusterUuid: string, topicName: string, kafkaTopicUpdate?: KafkaTopicUpdate, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesCreateKafkaTopic201Response>>;
    databasesUpdateLogsink(databaseClusterUuid: string, logsinkId: string, logsinkUpdate: LogsinkUpdate, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesUpdateMaintenanceWindow(databaseClusterUuid: string, databaseMaintenanceWindow: DatabaseMaintenanceWindow | null, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesUpdateMajorVersion(databaseClusterUuid: string, version2: Version2, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesUpdateOnlineMigration(databaseClusterUuid: string, sourceDatabase: SourceDatabase, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<OnlineMigration>>;
    databasesUpdateRegion(databaseClusterUuid: string, databasesUpdateRegionRequest: DatabasesUpdateRegionRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesUpdateSqlMode(databaseClusterUuid: string, sqlMode: SqlMode, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    databasesUpdateUser(databaseClusterUuid: string, username: string, databasesUpdateUserRequest: DatabasesUpdateUserRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DatabasesAddUser201Response>>;
};
export declare const DatabasesApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    databasesAdd(databaseClusterUuid: string, database: Database, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesAdd201Response>;
    databasesAddConnectionPool(databaseClusterUuid: string, connectionPool: ConnectionPool, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesAddConnectionPool201Response>;
    databasesAddUser(databaseClusterUuid: string, databasesAddUserRequest: DatabasesAddUserRequest, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesAddUser201Response>;
    databasesCreateCluster(databasesCreateClusterRequest: DatabasesCreateClusterRequest, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesCreateCluster201Response>;
    databasesCreateKafkaTopic(databaseClusterUuid: string, kafkaTopicCreate?: KafkaTopicCreate, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesCreateKafkaTopic201Response>;
    databasesCreateLogsink(databaseClusterUuid: string, logsinkCreate: LogsinkCreate, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesCreateLogsink201Response>;
    databasesCreateReplica(databaseClusterUuid: string, databaseReplica?: DatabaseReplica, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesCreateReplica201Response>;
    databasesDelete(databaseClusterUuid: string, databaseName: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesDeleteConnectionPool(databaseClusterUuid: string, poolName: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesDeleteKafkaTopic(databaseClusterUuid: string, topicName: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesDeleteLogsink(databaseClusterUuid: string, logsinkId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesDeleteOnlineMigration(databaseClusterUuid: string, migrationId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesDeleteOpensearchIndex(databaseClusterUuid: string, indexName: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesDeleteUser(databaseClusterUuid: string, username: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesDestroyCluster(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesDestroyReplica(databaseClusterUuid: string, replicaName: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesGet(databaseClusterUuid: string, databaseName: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesAdd201Response>;
    databasesGetCa(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesGetCa200Response>;
    databasesGetCluster(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesCreateCluster201Response>;
    databasesGetClusterMetricsCredentials(options?: RawAxiosRequestConfig): AxiosPromise<DatabasesGetClusterMetricsCredentials200Response>;
    databasesGetConfig(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesGetConfig200Response>;
    databasesGetConnectionPool(databaseClusterUuid: string, poolName: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesAddConnectionPool201Response>;
    databasesGetEvictionPolicy(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesGetEvictionPolicy200Response>;
    databasesGetKafkaTopic(databaseClusterUuid: string, topicName: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesCreateKafkaTopic201Response>;
    databasesGetLogsink(databaseClusterUuid: string, logsinkId: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesCreateLogsink201Response>;
    databasesGetMigrationStatus(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<OnlineMigration>;
    databasesGetReplica(databaseClusterUuid: string, replicaName: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesCreateReplica201Response>;
    databasesGetSqlMode(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<SqlMode>;
    databasesGetUser(databaseClusterUuid: string, username: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesAddUser201Response>;
    databasesList(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesList200Response>;
    databasesListBackups(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesListBackups200Response>;
    databasesListClusters(tagName?: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesListClusters200Response>;
    databasesListConnectionPools(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<ConnectionPools>;
    databasesListEventsLogs(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesListEventsLogs200Response>;
    databasesListFirewallRules(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesListFirewallRules200Response>;
    databasesListKafkaTopics(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesListKafkaTopics200Response>;
    databasesListLogsink(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesListLogsink201Response>;
    databasesListOpeasearchIndexes(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesListOpeasearchIndexes200Response>;
    databasesListOptions(options?: RawAxiosRequestConfig): AxiosPromise<Options>;
    databasesListReplicas(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesListReplicas200Response>;
    databasesListUsers(databaseClusterUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesListUsers200Response>;
    databasesPatchConfig(databaseClusterUuid: string, databaseConfig: DatabaseConfig, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesPromoteReplica(databaseClusterUuid: string, replicaName: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesResetAuth(databaseClusterUuid: string, username: string, databasesResetAuthRequest: DatabasesResetAuthRequest, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesAddUser201Response>;
    databasesUpdateClusterMetricsCredentials(databaseMetricsCredentials?: DatabaseMetricsCredentials, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesUpdateClusterSize(databaseClusterUuid: string, databaseClusterResize: DatabaseClusterResize, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesUpdateConnectionPool(databaseClusterUuid: string, poolName: string, connectionPoolUpdate: ConnectionPoolUpdate, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesUpdateEvictionPolicy(databaseClusterUuid: string, databasesUpdateEvictionPolicyRequest: DatabasesUpdateEvictionPolicyRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesUpdateFirewallRules(databaseClusterUuid: string, databasesUpdateFirewallRulesRequest: DatabasesUpdateFirewallRulesRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesUpdateKafkaTopic(databaseClusterUuid: string, topicName: string, kafkaTopicUpdate?: KafkaTopicUpdate, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesCreateKafkaTopic201Response>;
    databasesUpdateLogsink(databaseClusterUuid: string, logsinkId: string, logsinkUpdate: LogsinkUpdate, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesUpdateMaintenanceWindow(databaseClusterUuid: string, databaseMaintenanceWindow: DatabaseMaintenanceWindow | null, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesUpdateMajorVersion(databaseClusterUuid: string, version2: Version2, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesUpdateOnlineMigration(databaseClusterUuid: string, sourceDatabase: SourceDatabase, options?: RawAxiosRequestConfig): AxiosPromise<OnlineMigration>;
    databasesUpdateRegion(databaseClusterUuid: string, databasesUpdateRegionRequest: DatabasesUpdateRegionRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesUpdateSqlMode(databaseClusterUuid: string, sqlMode: SqlMode, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    databasesUpdateUser(databaseClusterUuid: string, username: string, databasesUpdateUserRequest: DatabasesUpdateUserRequest, options?: RawAxiosRequestConfig): AxiosPromise<DatabasesAddUser201Response>;
};
export declare class DatabasesApi extends BaseAPI {
    databasesAdd(databaseClusterUuid: string, database: Database, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesAdd201Response, any>>;
    databasesAddConnectionPool(databaseClusterUuid: string, connectionPool: ConnectionPool, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesAddConnectionPool201Response, any>>;
    databasesAddUser(databaseClusterUuid: string, databasesAddUserRequest: DatabasesAddUserRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesAddUser201Response, any>>;
    databasesCreateCluster(databasesCreateClusterRequest: DatabasesCreateClusterRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesCreateCluster201Response, any>>;
    databasesCreateKafkaTopic(databaseClusterUuid: string, kafkaTopicCreate?: KafkaTopicCreate, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesCreateKafkaTopic201Response, any>>;
    databasesCreateLogsink(databaseClusterUuid: string, logsinkCreate: LogsinkCreate, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesCreateLogsink201Response, any>>;
    databasesCreateReplica(databaseClusterUuid: string, databaseReplica?: DatabaseReplica, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesCreateReplica201Response, any>>;
    databasesDelete(databaseClusterUuid: string, databaseName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesDeleteConnectionPool(databaseClusterUuid: string, poolName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesDeleteKafkaTopic(databaseClusterUuid: string, topicName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesDeleteLogsink(databaseClusterUuid: string, logsinkId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesDeleteOnlineMigration(databaseClusterUuid: string, migrationId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesDeleteOpensearchIndex(databaseClusterUuid: string, indexName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesDeleteUser(databaseClusterUuid: string, username: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesDestroyCluster(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesDestroyReplica(databaseClusterUuid: string, replicaName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesGet(databaseClusterUuid: string, databaseName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesAdd201Response, any>>;
    databasesGetCa(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesGetCa200Response, any>>;
    databasesGetCluster(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesCreateCluster201Response, any>>;
    databasesGetClusterMetricsCredentials(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesGetClusterMetricsCredentials200Response, any>>;
    databasesGetConfig(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesGetConfig200Response, any>>;
    databasesGetConnectionPool(databaseClusterUuid: string, poolName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesAddConnectionPool201Response, any>>;
    databasesGetEvictionPolicy(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesGetEvictionPolicy200Response, any>>;
    databasesGetKafkaTopic(databaseClusterUuid: string, topicName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesCreateKafkaTopic201Response, any>>;
    databasesGetLogsink(databaseClusterUuid: string, logsinkId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesCreateLogsink201Response, any>>;
    databasesGetMigrationStatus(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<OnlineMigration, any>>;
    databasesGetReplica(databaseClusterUuid: string, replicaName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesCreateReplica201Response, any>>;
    databasesGetSqlMode(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<SqlMode, any>>;
    databasesGetUser(databaseClusterUuid: string, username: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesAddUser201Response, any>>;
    databasesList(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesList200Response, any>>;
    databasesListBackups(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesListBackups200Response, any>>;
    databasesListClusters(tagName?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesListClusters200Response, any>>;
    databasesListConnectionPools(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ConnectionPools, any>>;
    databasesListEventsLogs(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesListEventsLogs200Response, any>>;
    databasesListFirewallRules(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesListFirewallRules200Response, any>>;
    databasesListKafkaTopics(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesListKafkaTopics200Response, any>>;
    databasesListLogsink(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesListLogsink201Response, any>>;
    databasesListOpeasearchIndexes(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesListOpeasearchIndexes200Response, any>>;
    databasesListOptions(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Options, any>>;
    databasesListReplicas(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesListReplicas200Response, any>>;
    databasesListUsers(databaseClusterUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesListUsers200Response, any>>;
    databasesPatchConfig(databaseClusterUuid: string, databaseConfig: DatabaseConfig, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesPromoteReplica(databaseClusterUuid: string, replicaName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesResetAuth(databaseClusterUuid: string, username: string, databasesResetAuthRequest: DatabasesResetAuthRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesAddUser201Response, any>>;
    databasesUpdateClusterMetricsCredentials(databaseMetricsCredentials?: DatabaseMetricsCredentials, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesUpdateClusterSize(databaseClusterUuid: string, databaseClusterResize: DatabaseClusterResize, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesUpdateConnectionPool(databaseClusterUuid: string, poolName: string, connectionPoolUpdate: ConnectionPoolUpdate, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesUpdateEvictionPolicy(databaseClusterUuid: string, databasesUpdateEvictionPolicyRequest: DatabasesUpdateEvictionPolicyRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesUpdateFirewallRules(databaseClusterUuid: string, databasesUpdateFirewallRulesRequest: DatabasesUpdateFirewallRulesRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesUpdateKafkaTopic(databaseClusterUuid: string, topicName: string, kafkaTopicUpdate?: KafkaTopicUpdate, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesCreateKafkaTopic201Response, any>>;
    databasesUpdateLogsink(databaseClusterUuid: string, logsinkId: string, logsinkUpdate: LogsinkUpdate, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesUpdateMaintenanceWindow(databaseClusterUuid: string, databaseMaintenanceWindow: DatabaseMaintenanceWindow | null, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesUpdateMajorVersion(databaseClusterUuid: string, version2: Version2, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesUpdateOnlineMigration(databaseClusterUuid: string, sourceDatabase: SourceDatabase, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<OnlineMigration, any>>;
    databasesUpdateRegion(databaseClusterUuid: string, databasesUpdateRegionRequest: DatabasesUpdateRegionRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesUpdateSqlMode(databaseClusterUuid: string, sqlMode: SqlMode, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    databasesUpdateUser(databaseClusterUuid: string, username: string, databasesUpdateUserRequest: DatabasesUpdateUserRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DatabasesAddUser201Response, any>>;
}
export declare const DomainRecordsApiAxiosParamCreator: (configuration?: Configuration) => {
    domainsCreateRecord: (domainName: string, domainsCreateRecordRequest?: DomainsCreateRecordRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    domainsDeleteRecord: (domainName: string, domainRecordId: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    domainsGetRecord: (domainName: string, domainRecordId: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    domainsListRecords: (domainName: string, name?: string, type?: DomainsListRecordsTypeEnum, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    domainsPatchRecord: (domainName: string, domainRecordId: number, domainRecord?: DomainRecord, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    domainsUpdateRecord: (domainName: string, domainRecordId: number, domainRecord?: DomainRecord, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const DomainRecordsApiFp: (configuration?: Configuration) => {
    domainsCreateRecord(domainName: string, domainsCreateRecordRequest?: DomainsCreateRecordRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DomainsCreateRecord201Response>>;
    domainsDeleteRecord(domainName: string, domainRecordId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    domainsGetRecord(domainName: string, domainRecordId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DomainsGetRecord200Response>>;
    domainsListRecords(domainName: string, name?: string, type?: DomainsListRecordsTypeEnum, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DomainsListRecords200Response>>;
    domainsPatchRecord(domainName: string, domainRecordId: number, domainRecord?: DomainRecord, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DomainsGetRecord200Response>>;
    domainsUpdateRecord(domainName: string, domainRecordId: number, domainRecord?: DomainRecord, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DomainsGetRecord200Response>>;
};
export declare const DomainRecordsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    domainsCreateRecord(domainName: string, domainsCreateRecordRequest?: DomainsCreateRecordRequest, options?: RawAxiosRequestConfig): AxiosPromise<DomainsCreateRecord201Response>;
    domainsDeleteRecord(domainName: string, domainRecordId: number, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    domainsGetRecord(domainName: string, domainRecordId: number, options?: RawAxiosRequestConfig): AxiosPromise<DomainsGetRecord200Response>;
    domainsListRecords(domainName: string, name?: string, type?: DomainsListRecordsTypeEnum, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<DomainsListRecords200Response>;
    domainsPatchRecord(domainName: string, domainRecordId: number, domainRecord?: DomainRecord, options?: RawAxiosRequestConfig): AxiosPromise<DomainsGetRecord200Response>;
    domainsUpdateRecord(domainName: string, domainRecordId: number, domainRecord?: DomainRecord, options?: RawAxiosRequestConfig): AxiosPromise<DomainsGetRecord200Response>;
};
export declare class DomainRecordsApi extends BaseAPI {
    domainsCreateRecord(domainName: string, domainsCreateRecordRequest?: DomainsCreateRecordRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DomainsCreateRecord201Response, any>>;
    domainsDeleteRecord(domainName: string, domainRecordId: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    domainsGetRecord(domainName: string, domainRecordId: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DomainsGetRecord200Response, any>>;
    domainsListRecords(domainName: string, name?: string, type?: DomainsListRecordsTypeEnum, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DomainsListRecords200Response, any>>;
    domainsPatchRecord(domainName: string, domainRecordId: number, domainRecord?: DomainRecord, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DomainsGetRecord200Response, any>>;
    domainsUpdateRecord(domainName: string, domainRecordId: number, domainRecord?: DomainRecord, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DomainsGetRecord200Response, any>>;
}
export declare const DomainsListRecordsTypeEnum: {
    readonly A: "A";
    readonly Aaaa: "AAAA";
    readonly Caa: "CAA";
    readonly Cname: "CNAME";
    readonly Mx: "MX";
    readonly Ns: "NS";
    readonly Soa: "SOA";
    readonly Srv: "SRV";
    readonly Txt: "TXT";
};
export type DomainsListRecordsTypeEnum = (typeof DomainsListRecordsTypeEnum)[keyof typeof DomainsListRecordsTypeEnum];
export declare const DomainsApiAxiosParamCreator: (configuration?: Configuration) => {
    domainsCreate: (domain?: Domain, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    domainsDelete: (domainName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    domainsGet: (domainName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    domainsList: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const DomainsApiFp: (configuration?: Configuration) => {
    domainsCreate(domain?: Domain, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DomainsCreate201Response>>;
    domainsDelete(domainName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    domainsGet(domainName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DomainsGet200Response>>;
    domainsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DomainsList200Response>>;
};
export declare const DomainsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    domainsCreate(domain?: Domain, options?: RawAxiosRequestConfig): AxiosPromise<DomainsCreate201Response>;
    domainsDelete(domainName: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    domainsGet(domainName: string, options?: RawAxiosRequestConfig): AxiosPromise<DomainsGet200Response>;
    domainsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<DomainsList200Response>;
};
export declare class DomainsApi extends BaseAPI {
    domainsCreate(domain?: Domain, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DomainsCreate201Response, any>>;
    domainsDelete(domainName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    domainsGet(domainName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DomainsGet200Response, any>>;
    domainsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DomainsList200Response, any>>;
}
export declare const DropletActionsApiAxiosParamCreator: (configuration?: Configuration) => {
    dropletActionsGet: (dropletId: number, actionId: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletActionsList: (dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletActionsPost: (dropletId: number, dropletActionsPostRequest?: DropletActionsPostRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletActionsPostByTag: (tagName?: string, dropletActionsPostByTagRequest?: DropletActionsPostByTagRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const DropletActionsApiFp: (configuration?: Configuration) => {
    dropletActionsGet(dropletId: number, actionId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ActionsGet200Response>>;
    dropletActionsList(dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ActionsList200Response>>;
    dropletActionsPost(dropletId: number, dropletActionsPostRequest?: DropletActionsPostRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ActionsGet200Response>>;
    dropletActionsPostByTag(tagName?: string, dropletActionsPostByTagRequest?: DropletActionsPostByTagRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DropletActionsPostByTag201Response>>;
};
export declare const DropletActionsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    dropletActionsGet(dropletId: number, actionId: number, options?: RawAxiosRequestConfig): AxiosPromise<ActionsGet200Response>;
    dropletActionsList(dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<ActionsList200Response>;
    dropletActionsPost(dropletId: number, dropletActionsPostRequest?: DropletActionsPostRequest, options?: RawAxiosRequestConfig): AxiosPromise<ActionsGet200Response>;
    dropletActionsPostByTag(tagName?: string, dropletActionsPostByTagRequest?: DropletActionsPostByTagRequest, options?: RawAxiosRequestConfig): AxiosPromise<DropletActionsPostByTag201Response>;
};
export declare class DropletActionsApi extends BaseAPI {
    dropletActionsGet(dropletId: number, actionId: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ActionsGet200Response, any>>;
    dropletActionsList(dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ActionsList200Response, any>>;
    dropletActionsPost(dropletId: number, dropletActionsPostRequest?: DropletActionsPostRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ActionsGet200Response, any>>;
    dropletActionsPostByTag(tagName?: string, dropletActionsPostByTagRequest?: DropletActionsPostByTagRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DropletActionsPostByTag201Response, any>>;
}
export declare const DropletsApiAxiosParamCreator: (configuration?: Configuration) => {
    dropletsCreate: (dropletsCreateRequest?: DropletsCreateRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletsDestroy: (dropletId: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletsDestroyByTag: (tagName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletsDestroyRetryWithAssociatedResources: (dropletId: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletsDestroyWithAssociatedResourcesDangerous: (dropletId: number, xDangerous: boolean, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletsDestroyWithAssociatedResourcesSelective: (dropletId: number, selectiveDestroyAssociatedResource?: SelectiveDestroyAssociatedResource, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletsGet: (dropletId: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletsGetDestroyAssociatedResourcesStatus: (dropletId: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletsList: (perPage?: number, page?: number, tagName?: string, name?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletsListAssociatedResources: (dropletId: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletsListBackups: (dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletsListFirewalls: (dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletsListKernels: (dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletsListNeighbors: (dropletId: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletsListNeighborsIds: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    dropletsListSnapshots: (dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const DropletsApiFp: (configuration?: Configuration) => {
    dropletsCreate(dropletsCreateRequest?: DropletsCreateRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DropletsCreate202Response>>;
    dropletsDestroy(dropletId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    dropletsDestroyByTag(tagName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    dropletsDestroyRetryWithAssociatedResources(dropletId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    dropletsDestroyWithAssociatedResourcesDangerous(dropletId: number, xDangerous: boolean, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    dropletsDestroyWithAssociatedResourcesSelective(dropletId: number, selectiveDestroyAssociatedResource?: SelectiveDestroyAssociatedResource, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    dropletsGet(dropletId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DropletsGet200Response>>;
    dropletsGetDestroyAssociatedResourcesStatus(dropletId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AssociatedResourceStatus>>;
    dropletsList(perPage?: number, page?: number, tagName?: string, name?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DropletsList200Response>>;
    dropletsListAssociatedResources(dropletId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DropletsListAssociatedResources200Response>>;
    dropletsListBackups(dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DropletsListBackups200Response>>;
    dropletsListFirewalls(dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DropletsListFirewalls200Response>>;
    dropletsListKernels(dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DropletsListKernels200Response>>;
    dropletsListNeighbors(dropletId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DropletsListNeighbors200Response>>;
    dropletsListNeighborsIds(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<NeighborIds>>;
    dropletsListSnapshots(dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DropletsListSnapshots200Response>>;
};
export declare const DropletsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    dropletsCreate(dropletsCreateRequest?: DropletsCreateRequest, options?: RawAxiosRequestConfig): AxiosPromise<DropletsCreate202Response>;
    dropletsDestroy(dropletId: number, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    dropletsDestroyByTag(tagName: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    dropletsDestroyRetryWithAssociatedResources(dropletId: number, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    dropletsDestroyWithAssociatedResourcesDangerous(dropletId: number, xDangerous: boolean, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    dropletsDestroyWithAssociatedResourcesSelective(dropletId: number, selectiveDestroyAssociatedResource?: SelectiveDestroyAssociatedResource, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    dropletsGet(dropletId: number, options?: RawAxiosRequestConfig): AxiosPromise<DropletsGet200Response>;
    dropletsGetDestroyAssociatedResourcesStatus(dropletId: number, options?: RawAxiosRequestConfig): AxiosPromise<AssociatedResourceStatus>;
    dropletsList(perPage?: number, page?: number, tagName?: string, name?: string, options?: RawAxiosRequestConfig): AxiosPromise<DropletsList200Response>;
    dropletsListAssociatedResources(dropletId: number, options?: RawAxiosRequestConfig): AxiosPromise<DropletsListAssociatedResources200Response>;
    dropletsListBackups(dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<DropletsListBackups200Response>;
    dropletsListFirewalls(dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<DropletsListFirewalls200Response>;
    dropletsListKernels(dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<DropletsListKernels200Response>;
    dropletsListNeighbors(dropletId: number, options?: RawAxiosRequestConfig): AxiosPromise<DropletsListNeighbors200Response>;
    dropletsListNeighborsIds(options?: RawAxiosRequestConfig): AxiosPromise<NeighborIds>;
    dropletsListSnapshots(dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<DropletsListSnapshots200Response>;
};
export declare class DropletsApi extends BaseAPI {
    dropletsCreate(dropletsCreateRequest?: DropletsCreateRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DropletsCreate202Response, any>>;
    dropletsDestroy(dropletId: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    dropletsDestroyByTag(tagName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    dropletsDestroyRetryWithAssociatedResources(dropletId: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    dropletsDestroyWithAssociatedResourcesDangerous(dropletId: number, xDangerous: boolean, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    dropletsDestroyWithAssociatedResourcesSelective(dropletId: number, selectiveDestroyAssociatedResource?: SelectiveDestroyAssociatedResource, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    dropletsGet(dropletId: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DropletsGet200Response, any>>;
    dropletsGetDestroyAssociatedResourcesStatus(dropletId: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AssociatedResourceStatus, any>>;
    dropletsList(perPage?: number, page?: number, tagName?: string, name?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DropletsList200Response, any>>;
    dropletsListAssociatedResources(dropletId: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DropletsListAssociatedResources200Response, any>>;
    dropletsListBackups(dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DropletsListBackups200Response, any>>;
    dropletsListFirewalls(dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DropletsListFirewalls200Response, any>>;
    dropletsListKernels(dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DropletsListKernels200Response, any>>;
    dropletsListNeighbors(dropletId: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DropletsListNeighbors200Response, any>>;
    dropletsListNeighborsIds(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<NeighborIds, any>>;
    dropletsListSnapshots(dropletId: number, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DropletsListSnapshots200Response, any>>;
}
export declare const FirewallsApiAxiosParamCreator: (configuration?: Configuration) => {
    firewallsAddRules: (firewallId: string, firewallsAddRulesRequest?: FirewallsAddRulesRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    firewallsAddTags: (firewallId: string, firewallsAddTagsRequest?: FirewallsAddTagsRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    firewallsAssignDroplets: (firewallId: string, firewallsAssignDropletsRequest?: FirewallsAssignDropletsRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    firewallsCreate: (firewallsCreateRequest?: FirewallsCreateRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    firewallsDelete: (firewallId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    firewallsDeleteDroplets: (firewallId: string, firewallsDeleteDropletsRequest?: FirewallsDeleteDropletsRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    firewallsDeleteRules: (firewallId: string, firewallsAddRulesRequest?: FirewallsAddRulesRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    firewallsDeleteTags: (firewallId: string, firewallsAddTagsRequest?: FirewallsAddTagsRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    firewallsGet: (firewallId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    firewallsList: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    firewallsUpdate: (firewallId: string, firewallsUpdateRequest?: FirewallsUpdateRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const FirewallsApiFp: (configuration?: Configuration) => {
    firewallsAddRules(firewallId: string, firewallsAddRulesRequest?: FirewallsAddRulesRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    firewallsAddTags(firewallId: string, firewallsAddTagsRequest?: FirewallsAddTagsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    firewallsAssignDroplets(firewallId: string, firewallsAssignDropletsRequest?: FirewallsAssignDropletsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    firewallsCreate(firewallsCreateRequest?: FirewallsCreateRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FirewallsCreate202Response>>;
    firewallsDelete(firewallId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    firewallsDeleteDroplets(firewallId: string, firewallsDeleteDropletsRequest?: FirewallsDeleteDropletsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    firewallsDeleteRules(firewallId: string, firewallsAddRulesRequest?: FirewallsAddRulesRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    firewallsDeleteTags(firewallId: string, firewallsAddTagsRequest?: FirewallsAddTagsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    firewallsGet(firewallId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FirewallsCreate202Response>>;
    firewallsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DropletsListFirewalls200Response>>;
    firewallsUpdate(firewallId: string, firewallsUpdateRequest?: FirewallsUpdateRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FirewallsCreate202Response>>;
};
export declare const FirewallsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    firewallsAddRules(firewallId: string, firewallsAddRulesRequest?: FirewallsAddRulesRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    firewallsAddTags(firewallId: string, firewallsAddTagsRequest?: FirewallsAddTagsRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    firewallsAssignDroplets(firewallId: string, firewallsAssignDropletsRequest?: FirewallsAssignDropletsRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    firewallsCreate(firewallsCreateRequest?: FirewallsCreateRequest, options?: RawAxiosRequestConfig): AxiosPromise<FirewallsCreate202Response>;
    firewallsDelete(firewallId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    firewallsDeleteDroplets(firewallId: string, firewallsDeleteDropletsRequest?: FirewallsDeleteDropletsRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    firewallsDeleteRules(firewallId: string, firewallsAddRulesRequest?: FirewallsAddRulesRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    firewallsDeleteTags(firewallId: string, firewallsAddTagsRequest?: FirewallsAddTagsRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    firewallsGet(firewallId: string, options?: RawAxiosRequestConfig): AxiosPromise<FirewallsCreate202Response>;
    firewallsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<DropletsListFirewalls200Response>;
    firewallsUpdate(firewallId: string, firewallsUpdateRequest?: FirewallsUpdateRequest, options?: RawAxiosRequestConfig): AxiosPromise<FirewallsCreate202Response>;
};
export declare class FirewallsApi extends BaseAPI {
    firewallsAddRules(firewallId: string, firewallsAddRulesRequest?: FirewallsAddRulesRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    firewallsAddTags(firewallId: string, firewallsAddTagsRequest?: FirewallsAddTagsRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    firewallsAssignDroplets(firewallId: string, firewallsAssignDropletsRequest?: FirewallsAssignDropletsRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    firewallsCreate(firewallsCreateRequest?: FirewallsCreateRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FirewallsCreate202Response, any>>;
    firewallsDelete(firewallId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    firewallsDeleteDroplets(firewallId: string, firewallsDeleteDropletsRequest?: FirewallsDeleteDropletsRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    firewallsDeleteRules(firewallId: string, firewallsAddRulesRequest?: FirewallsAddRulesRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    firewallsDeleteTags(firewallId: string, firewallsAddTagsRequest?: FirewallsAddTagsRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    firewallsGet(firewallId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FirewallsCreate202Response, any>>;
    firewallsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<DropletsListFirewalls200Response, any>>;
    firewallsUpdate(firewallId: string, firewallsUpdateRequest?: FirewallsUpdateRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FirewallsCreate202Response, any>>;
}
export declare const FloatingIPActionsApiAxiosParamCreator: (configuration?: Configuration) => {
    floatingIPsActionGet: (floatingIp: string, actionId: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    floatingIPsActionList: (floatingIp: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    floatingIPsActionPost: (floatingIp: string, floatingIPsActionPostRequest?: FloatingIPsActionPostRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const FloatingIPActionsApiFp: (configuration?: Configuration) => {
    floatingIPsActionGet(floatingIp: string, actionId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FloatingIPsActionPost201Response>>;
    floatingIPsActionList(floatingIp: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FloatingIPsActionList200Response>>;
    floatingIPsActionPost(floatingIp: string, floatingIPsActionPostRequest?: FloatingIPsActionPostRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FloatingIPsActionPost201Response>>;
};
export declare const FloatingIPActionsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    floatingIPsActionGet(floatingIp: string, actionId: number, options?: RawAxiosRequestConfig): AxiosPromise<FloatingIPsActionPost201Response>;
    floatingIPsActionList(floatingIp: string, options?: RawAxiosRequestConfig): AxiosPromise<FloatingIPsActionList200Response>;
    floatingIPsActionPost(floatingIp: string, floatingIPsActionPostRequest?: FloatingIPsActionPostRequest, options?: RawAxiosRequestConfig): AxiosPromise<FloatingIPsActionPost201Response>;
};
export declare class FloatingIPActionsApi extends BaseAPI {
    floatingIPsActionGet(floatingIp: string, actionId: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FloatingIPsActionPost201Response, any>>;
    floatingIPsActionList(floatingIp: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FloatingIPsActionList200Response, any>>;
    floatingIPsActionPost(floatingIp: string, floatingIPsActionPostRequest?: FloatingIPsActionPostRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FloatingIPsActionPost201Response, any>>;
}
export declare const FloatingIPsApiAxiosParamCreator: (configuration?: Configuration) => {
    floatingIPsCreate: (floatingIpCreate: FloatingIpCreate, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    floatingIPsDelete: (floatingIp: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    floatingIPsGet: (floatingIp: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    floatingIPsList: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const FloatingIPsApiFp: (configuration?: Configuration) => {
    floatingIPsCreate(floatingIpCreate: FloatingIpCreate, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FloatingIPsCreate202Response>>;
    floatingIPsDelete(floatingIp: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    floatingIPsGet(floatingIp: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FloatingIPsGet200Response>>;
    floatingIPsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FloatingIPsList200Response>>;
};
export declare const FloatingIPsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    floatingIPsCreate(floatingIpCreate: FloatingIpCreate, options?: RawAxiosRequestConfig): AxiosPromise<FloatingIPsCreate202Response>;
    floatingIPsDelete(floatingIp: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    floatingIPsGet(floatingIp: string, options?: RawAxiosRequestConfig): AxiosPromise<FloatingIPsGet200Response>;
    floatingIPsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<FloatingIPsList200Response>;
};
export declare class FloatingIPsApi extends BaseAPI {
    floatingIPsCreate(floatingIpCreate: FloatingIpCreate, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FloatingIPsCreate202Response, any>>;
    floatingIPsDelete(floatingIp: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    floatingIPsGet(floatingIp: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FloatingIPsGet200Response, any>>;
    floatingIPsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FloatingIPsList200Response, any>>;
}
export declare const FunctionsApiAxiosParamCreator: (configuration?: Configuration) => {
    functionsCreateNamespace: (createNamespace: CreateNamespace, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    functionsCreateTrigger: (namespaceId: string, createTrigger: CreateTrigger, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    functionsDeleteNamespace: (namespaceId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    functionsDeleteTrigger: (namespaceId: string, triggerName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    functionsGetNamespace: (namespaceId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    functionsGetTrigger: (namespaceId: string, triggerName: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    functionsListNamespaces: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    functionsListTriggers: (namespaceId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    functionsUpdateTrigger: (namespaceId: string, triggerName: string, updateTrigger: UpdateTrigger, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const FunctionsApiFp: (configuration?: Configuration) => {
    functionsCreateNamespace(createNamespace: CreateNamespace, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FunctionsCreateNamespace200Response>>;
    functionsCreateTrigger(namespaceId: string, createTrigger: CreateTrigger, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FunctionsCreateTrigger200Response>>;
    functionsDeleteNamespace(namespaceId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    functionsDeleteTrigger(namespaceId: string, triggerName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    functionsGetNamespace(namespaceId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FunctionsCreateNamespace200Response>>;
    functionsGetTrigger(namespaceId: string, triggerName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FunctionsCreateTrigger200Response>>;
    functionsListNamespaces(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FunctionsListNamespaces200Response>>;
    functionsListTriggers(namespaceId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FunctionsListTriggers200Response>>;
    functionsUpdateTrigger(namespaceId: string, triggerName: string, updateTrigger: UpdateTrigger, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FunctionsCreateTrigger200Response>>;
};
export declare const FunctionsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    functionsCreateNamespace(createNamespace: CreateNamespace, options?: RawAxiosRequestConfig): AxiosPromise<FunctionsCreateNamespace200Response>;
    functionsCreateTrigger(namespaceId: string, createTrigger: CreateTrigger, options?: RawAxiosRequestConfig): AxiosPromise<FunctionsCreateTrigger200Response>;
    functionsDeleteNamespace(namespaceId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    functionsDeleteTrigger(namespaceId: string, triggerName: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    functionsGetNamespace(namespaceId: string, options?: RawAxiosRequestConfig): AxiosPromise<FunctionsCreateNamespace200Response>;
    functionsGetTrigger(namespaceId: string, triggerName: string, options?: RawAxiosRequestConfig): AxiosPromise<FunctionsCreateTrigger200Response>;
    functionsListNamespaces(options?: RawAxiosRequestConfig): AxiosPromise<FunctionsListNamespaces200Response>;
    functionsListTriggers(namespaceId: string, options?: RawAxiosRequestConfig): AxiosPromise<FunctionsListTriggers200Response>;
    functionsUpdateTrigger(namespaceId: string, triggerName: string, updateTrigger: UpdateTrigger, options?: RawAxiosRequestConfig): AxiosPromise<FunctionsCreateTrigger200Response>;
};
export declare class FunctionsApi extends BaseAPI {
    functionsCreateNamespace(createNamespace: CreateNamespace, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FunctionsCreateNamespace200Response, any>>;
    functionsCreateTrigger(namespaceId: string, createTrigger: CreateTrigger, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FunctionsCreateTrigger200Response, any>>;
    functionsDeleteNamespace(namespaceId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    functionsDeleteTrigger(namespaceId: string, triggerName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    functionsGetNamespace(namespaceId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FunctionsCreateNamespace200Response, any>>;
    functionsGetTrigger(namespaceId: string, triggerName: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FunctionsCreateTrigger200Response, any>>;
    functionsListNamespaces(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FunctionsListNamespaces200Response, any>>;
    functionsListTriggers(namespaceId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FunctionsListTriggers200Response, any>>;
    functionsUpdateTrigger(namespaceId: string, triggerName: string, updateTrigger: UpdateTrigger, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FunctionsCreateTrigger200Response, any>>;
}
export declare const ImageActionsApiAxiosParamCreator: (configuration?: Configuration) => {
    imageActionsGet: (imageId: number, actionId: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    imageActionsList: (imageId: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    imageActionsPost: (imageId: number, imageActionsPostRequest?: ImageActionsPostRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const ImageActionsApiFp: (configuration?: Configuration) => {
    imageActionsGet(imageId: number, actionId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Action>>;
    imageActionsList(imageId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ActionsList200Response>>;
    imageActionsPost(imageId: number, imageActionsPostRequest?: ImageActionsPostRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Action>>;
};
export declare const ImageActionsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    imageActionsGet(imageId: number, actionId: number, options?: RawAxiosRequestConfig): AxiosPromise<Action>;
    imageActionsList(imageId: number, options?: RawAxiosRequestConfig): AxiosPromise<ActionsList200Response>;
    imageActionsPost(imageId: number, imageActionsPostRequest?: ImageActionsPostRequest, options?: RawAxiosRequestConfig): AxiosPromise<Action>;
};
export declare class ImageActionsApi extends BaseAPI {
    imageActionsGet(imageId: number, actionId: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Action, any>>;
    imageActionsList(imageId: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ActionsList200Response, any>>;
    imageActionsPost(imageId: number, imageActionsPostRequest?: ImageActionsPostRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Action, any>>;
}
export declare const ImagesApiAxiosParamCreator: (configuration?: Configuration) => {
    imagesCreateCustom: (imageNewCustom: ImageNewCustom, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    imagesDelete: (imageId: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    imagesGet: (imageId: ImagesGetImageIdParameter, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    imagesList: (type?: ImagesListTypeEnum, _private?: boolean, tagName?: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    imagesUpdate: (imageId: number, imageUpdate: ImageUpdate, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const ImagesApiFp: (configuration?: Configuration) => {
    imagesCreateCustom(imageNewCustom: ImageNewCustom, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ImagesCreateCustom202Response>>;
    imagesDelete(imageId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    imagesGet(imageId: ImagesGetImageIdParameter, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ImagesGet200Response>>;
    imagesList(type?: ImagesListTypeEnum, _private?: boolean, tagName?: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ImagesList200Response>>;
    imagesUpdate(imageId: number, imageUpdate: ImageUpdate, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ImagesGet200Response>>;
};
export declare const ImagesApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    imagesCreateCustom(imageNewCustom: ImageNewCustom, options?: RawAxiosRequestConfig): AxiosPromise<ImagesCreateCustom202Response>;
    imagesDelete(imageId: number, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    imagesGet(imageId: ImagesGetImageIdParameter, options?: RawAxiosRequestConfig): AxiosPromise<ImagesGet200Response>;
    imagesList(type?: ImagesListTypeEnum, _private?: boolean, tagName?: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<ImagesList200Response>;
    imagesUpdate(imageId: number, imageUpdate: ImageUpdate, options?: RawAxiosRequestConfig): AxiosPromise<ImagesGet200Response>;
};
export declare class ImagesApi extends BaseAPI {
    imagesCreateCustom(imageNewCustom: ImageNewCustom, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ImagesCreateCustom202Response, any>>;
    imagesDelete(imageId: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    imagesGet(imageId: ImagesGetImageIdParameter, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ImagesGet200Response, any>>;
    imagesList(type?: ImagesListTypeEnum, _private?: boolean, tagName?: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ImagesList200Response, any>>;
    imagesUpdate(imageId: number, imageUpdate: ImageUpdate, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ImagesGet200Response, any>>;
}
export declare const ImagesListTypeEnum: {
    readonly Application: "application";
    readonly Distribution: "distribution";
};
export type ImagesListTypeEnum = (typeof ImagesListTypeEnum)[keyof typeof ImagesListTypeEnum];
export declare const KubernetesApiAxiosParamCreator: (configuration?: Configuration) => {
    kubernetesAddNodePool: (clusterId: string, kubernetesNodePool: KubernetesNodePool, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesAddRegistry: (clusterRegistries?: ClusterRegistries, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesCreateCluster: (cluster: Cluster, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesDeleteCluster: (clusterId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesDeleteNode: (clusterId: string, nodePoolId: string, nodeId: string, skipDrain?: number, replace?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesDeleteNodePool: (clusterId: string, nodePoolId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesDestroyAssociatedResourcesDangerous: (clusterId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesDestroyAssociatedResourcesSelective: (clusterId: string, destroyAssociatedKubernetesResources: DestroyAssociatedKubernetesResources, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesGetAvailableUpgrades: (clusterId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesGetCluster: (clusterId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesGetClusterLintResults: (clusterId: string, runId?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesGetClusterUser: (clusterId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesGetCredentials: (clusterId: string, expirySeconds?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesGetKubeconfig: (clusterId: string, expirySeconds?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesGetNodePool: (clusterId: string, nodePoolId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesListAssociatedResources: (clusterId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesListClusters: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesListNodePools: (clusterId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesListOptions: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesRecycleNodePool: (clusterId: string, nodePoolId: string, kubernetesRecycleNodePoolRequest: KubernetesRecycleNodePoolRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesRemoveRegistry: (clusterRegistries?: ClusterRegistries, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesRunClusterLint: (clusterId: string, clusterlintRequest?: ClusterlintRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesUpdateCluster: (clusterId: string, clusterUpdate: ClusterUpdate, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesUpdateNodePool: (clusterId: string, nodePoolId: string, kubernetesNodePoolUpdate: KubernetesNodePoolUpdate, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    kubernetesUpgradeCluster: (clusterId: string, kubernetesUpgradeClusterRequest: KubernetesUpgradeClusterRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const KubernetesApiFp: (configuration?: Configuration) => {
    kubernetesAddNodePool(clusterId: string, kubernetesNodePool: KubernetesNodePool, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<KubernetesAddNodePool201Response>>;
    kubernetesAddRegistry(clusterRegistries?: ClusterRegistries, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    kubernetesCreateCluster(cluster: Cluster, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<KubernetesCreateCluster201Response>>;
    kubernetesDeleteCluster(clusterId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    kubernetesDeleteNode(clusterId: string, nodePoolId: string, nodeId: string, skipDrain?: number, replace?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    kubernetesDeleteNodePool(clusterId: string, nodePoolId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    kubernetesDestroyAssociatedResourcesDangerous(clusterId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    kubernetesDestroyAssociatedResourcesSelective(clusterId: string, destroyAssociatedKubernetesResources: DestroyAssociatedKubernetesResources, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    kubernetesGetAvailableUpgrades(clusterId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<KubernetesGetAvailableUpgrades200Response>>;
    kubernetesGetCluster(clusterId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<KubernetesCreateCluster201Response>>;
    kubernetesGetClusterLintResults(clusterId: string, runId?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ClusterlintResults>>;
    kubernetesGetClusterUser(clusterId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<User>>;
    kubernetesGetCredentials(clusterId: string, expirySeconds?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Credentials>>;
    kubernetesGetKubeconfig(clusterId: string, expirySeconds?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    kubernetesGetNodePool(clusterId: string, nodePoolId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<KubernetesGetNodePool200Response>>;
    kubernetesListAssociatedResources(clusterId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AssociatedKubernetesResources>>;
    kubernetesListClusters(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<KubernetesListClusters200Response>>;
    kubernetesListNodePools(clusterId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<KubernetesListNodePools200Response>>;
    kubernetesListOptions(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<KubernetesOptions>>;
    kubernetesRecycleNodePool(clusterId: string, nodePoolId: string, kubernetesRecycleNodePoolRequest: KubernetesRecycleNodePoolRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    kubernetesRemoveRegistry(clusterRegistries?: ClusterRegistries, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    kubernetesRunClusterLint(clusterId: string, clusterlintRequest?: ClusterlintRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<KubernetesRunClusterLint202Response>>;
    kubernetesUpdateCluster(clusterId: string, clusterUpdate: ClusterUpdate, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<KubernetesCreateCluster201Response>>;
    kubernetesUpdateNodePool(clusterId: string, nodePoolId: string, kubernetesNodePoolUpdate: KubernetesNodePoolUpdate, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<KubernetesUpdateNodePool202Response>>;
    kubernetesUpgradeCluster(clusterId: string, kubernetesUpgradeClusterRequest: KubernetesUpgradeClusterRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
};
export declare const KubernetesApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    kubernetesAddNodePool(clusterId: string, kubernetesNodePool: KubernetesNodePool, options?: RawAxiosRequestConfig): AxiosPromise<KubernetesAddNodePool201Response>;
    kubernetesAddRegistry(clusterRegistries?: ClusterRegistries, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    kubernetesCreateCluster(cluster: Cluster, options?: RawAxiosRequestConfig): AxiosPromise<KubernetesCreateCluster201Response>;
    kubernetesDeleteCluster(clusterId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    kubernetesDeleteNode(clusterId: string, nodePoolId: string, nodeId: string, skipDrain?: number, replace?: number, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    kubernetesDeleteNodePool(clusterId: string, nodePoolId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    kubernetesDestroyAssociatedResourcesDangerous(clusterId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    kubernetesDestroyAssociatedResourcesSelective(clusterId: string, destroyAssociatedKubernetesResources: DestroyAssociatedKubernetesResources, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    kubernetesGetAvailableUpgrades(clusterId: string, options?: RawAxiosRequestConfig): AxiosPromise<KubernetesGetAvailableUpgrades200Response>;
    kubernetesGetCluster(clusterId: string, options?: RawAxiosRequestConfig): AxiosPromise<KubernetesCreateCluster201Response>;
    kubernetesGetClusterLintResults(clusterId: string, runId?: string, options?: RawAxiosRequestConfig): AxiosPromise<ClusterlintResults>;
    kubernetesGetClusterUser(clusterId: string, options?: RawAxiosRequestConfig): AxiosPromise<User>;
    kubernetesGetCredentials(clusterId: string, expirySeconds?: number, options?: RawAxiosRequestConfig): AxiosPromise<Credentials>;
    kubernetesGetKubeconfig(clusterId: string, expirySeconds?: number, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    kubernetesGetNodePool(clusterId: string, nodePoolId: string, options?: RawAxiosRequestConfig): AxiosPromise<KubernetesGetNodePool200Response>;
    kubernetesListAssociatedResources(clusterId: string, options?: RawAxiosRequestConfig): AxiosPromise<AssociatedKubernetesResources>;
    kubernetesListClusters(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<KubernetesListClusters200Response>;
    kubernetesListNodePools(clusterId: string, options?: RawAxiosRequestConfig): AxiosPromise<KubernetesListNodePools200Response>;
    kubernetesListOptions(options?: RawAxiosRequestConfig): AxiosPromise<KubernetesOptions>;
    kubernetesRecycleNodePool(clusterId: string, nodePoolId: string, kubernetesRecycleNodePoolRequest: KubernetesRecycleNodePoolRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    kubernetesRemoveRegistry(clusterRegistries?: ClusterRegistries, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    kubernetesRunClusterLint(clusterId: string, clusterlintRequest?: ClusterlintRequest, options?: RawAxiosRequestConfig): AxiosPromise<KubernetesRunClusterLint202Response>;
    kubernetesUpdateCluster(clusterId: string, clusterUpdate: ClusterUpdate, options?: RawAxiosRequestConfig): AxiosPromise<KubernetesCreateCluster201Response>;
    kubernetesUpdateNodePool(clusterId: string, nodePoolId: string, kubernetesNodePoolUpdate: KubernetesNodePoolUpdate, options?: RawAxiosRequestConfig): AxiosPromise<KubernetesUpdateNodePool202Response>;
    kubernetesUpgradeCluster(clusterId: string, kubernetesUpgradeClusterRequest: KubernetesUpgradeClusterRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
};
export declare class KubernetesApi extends BaseAPI {
    kubernetesAddNodePool(clusterId: string, kubernetesNodePool: KubernetesNodePool, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<KubernetesAddNodePool201Response, any>>;
    kubernetesAddRegistry(clusterRegistries?: ClusterRegistries, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    kubernetesCreateCluster(cluster: Cluster, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<KubernetesCreateCluster201Response, any>>;
    kubernetesDeleteCluster(clusterId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    kubernetesDeleteNode(clusterId: string, nodePoolId: string, nodeId: string, skipDrain?: number, replace?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    kubernetesDeleteNodePool(clusterId: string, nodePoolId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    kubernetesDestroyAssociatedResourcesDangerous(clusterId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    kubernetesDestroyAssociatedResourcesSelective(clusterId: string, destroyAssociatedKubernetesResources: DestroyAssociatedKubernetesResources, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    kubernetesGetAvailableUpgrades(clusterId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<KubernetesGetAvailableUpgrades200Response, any>>;
    kubernetesGetCluster(clusterId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<KubernetesCreateCluster201Response, any>>;
    kubernetesGetClusterLintResults(clusterId: string, runId?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ClusterlintResults, any>>;
    kubernetesGetClusterUser(clusterId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<User, any>>;
    kubernetesGetCredentials(clusterId: string, expirySeconds?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Credentials, any>>;
    kubernetesGetKubeconfig(clusterId: string, expirySeconds?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    kubernetesGetNodePool(clusterId: string, nodePoolId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<KubernetesGetNodePool200Response, any>>;
    kubernetesListAssociatedResources(clusterId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AssociatedKubernetesResources, any>>;
    kubernetesListClusters(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<KubernetesListClusters200Response, any>>;
    kubernetesListNodePools(clusterId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<KubernetesListNodePools200Response, any>>;
    kubernetesListOptions(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<KubernetesOptions, any>>;
    kubernetesRecycleNodePool(clusterId: string, nodePoolId: string, kubernetesRecycleNodePoolRequest: KubernetesRecycleNodePoolRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    kubernetesRemoveRegistry(clusterRegistries?: ClusterRegistries, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    kubernetesRunClusterLint(clusterId: string, clusterlintRequest?: ClusterlintRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<KubernetesRunClusterLint202Response, any>>;
    kubernetesUpdateCluster(clusterId: string, clusterUpdate: ClusterUpdate, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<KubernetesCreateCluster201Response, any>>;
    kubernetesUpdateNodePool(clusterId: string, nodePoolId: string, kubernetesNodePoolUpdate: KubernetesNodePoolUpdate, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<KubernetesUpdateNodePool202Response, any>>;
    kubernetesUpgradeCluster(clusterId: string, kubernetesUpgradeClusterRequest: KubernetesUpgradeClusterRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
}
export declare const LoadBalancersApiAxiosParamCreator: (configuration?: Configuration) => {
    loadBalancersAddDroplets: (lbId: string, loadBalancersAddDropletsRequest: LoadBalancersAddDropletsRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    loadBalancersAddForwardingRules: (lbId: string, loadBalancersAddForwardingRulesRequest: LoadBalancersAddForwardingRulesRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    loadBalancersCreate: (loadBalancerCreate: LoadBalancerCreate, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    loadBalancersDelete: (lbId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    loadBalancersGet: (lbId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    loadBalancersList: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    loadBalancersRemoveDroplets: (lbId: string, loadBalancersAddDropletsRequest: LoadBalancersAddDropletsRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    loadBalancersRemoveForwardingRules: (lbId: string, loadBalancersAddForwardingRulesRequest: LoadBalancersAddForwardingRulesRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    loadBalancersUpdate: (lbId: string, loadBalancerCreate: LoadBalancerCreate, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const LoadBalancersApiFp: (configuration?: Configuration) => {
    loadBalancersAddDroplets(lbId: string, loadBalancersAddDropletsRequest: LoadBalancersAddDropletsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    loadBalancersAddForwardingRules(lbId: string, loadBalancersAddForwardingRulesRequest: LoadBalancersAddForwardingRulesRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    loadBalancersCreate(loadBalancerCreate: LoadBalancerCreate, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<LoadBalancersCreate202Response>>;
    loadBalancersDelete(lbId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    loadBalancersGet(lbId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<LoadBalancersCreate202Response>>;
    loadBalancersList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<LoadBalancersList200Response>>;
    loadBalancersRemoveDroplets(lbId: string, loadBalancersAddDropletsRequest: LoadBalancersAddDropletsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    loadBalancersRemoveForwardingRules(lbId: string, loadBalancersAddForwardingRulesRequest: LoadBalancersAddForwardingRulesRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    loadBalancersUpdate(lbId: string, loadBalancerCreate: LoadBalancerCreate, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<LoadBalancersCreate202Response>>;
};
export declare const LoadBalancersApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    loadBalancersAddDroplets(lbId: string, loadBalancersAddDropletsRequest: LoadBalancersAddDropletsRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    loadBalancersAddForwardingRules(lbId: string, loadBalancersAddForwardingRulesRequest: LoadBalancersAddForwardingRulesRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    loadBalancersCreate(loadBalancerCreate: LoadBalancerCreate, options?: RawAxiosRequestConfig): AxiosPromise<LoadBalancersCreate202Response>;
    loadBalancersDelete(lbId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    loadBalancersGet(lbId: string, options?: RawAxiosRequestConfig): AxiosPromise<LoadBalancersCreate202Response>;
    loadBalancersList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<LoadBalancersList200Response>;
    loadBalancersRemoveDroplets(lbId: string, loadBalancersAddDropletsRequest: LoadBalancersAddDropletsRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    loadBalancersRemoveForwardingRules(lbId: string, loadBalancersAddForwardingRulesRequest: LoadBalancersAddForwardingRulesRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    loadBalancersUpdate(lbId: string, loadBalancerCreate: LoadBalancerCreate, options?: RawAxiosRequestConfig): AxiosPromise<LoadBalancersCreate202Response>;
};
export declare class LoadBalancersApi extends BaseAPI {
    loadBalancersAddDroplets(lbId: string, loadBalancersAddDropletsRequest: LoadBalancersAddDropletsRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    loadBalancersAddForwardingRules(lbId: string, loadBalancersAddForwardingRulesRequest: LoadBalancersAddForwardingRulesRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    loadBalancersCreate(loadBalancerCreate: LoadBalancerCreate, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<LoadBalancersCreate202Response, any>>;
    loadBalancersDelete(lbId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    loadBalancersGet(lbId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<LoadBalancersCreate202Response, any>>;
    loadBalancersList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<LoadBalancersList200Response, any>>;
    loadBalancersRemoveDroplets(lbId: string, loadBalancersAddDropletsRequest: LoadBalancersAddDropletsRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    loadBalancersRemoveForwardingRules(lbId: string, loadBalancersAddForwardingRulesRequest: LoadBalancersAddForwardingRulesRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    loadBalancersUpdate(lbId: string, loadBalancerCreate: LoadBalancerCreate, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<LoadBalancersCreate202Response, any>>;
}
export declare const MonitoringApiAxiosParamCreator: (configuration?: Configuration) => {
    monitoringCreateAlertPolicy: (alertPolicyRequest: AlertPolicyRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringDeleteAlertPolicy: (alertUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetAlertPolicy: (alertUuid: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetAppCPUPercentageMetrics: (appId: string, start: string, end: string, appComponent?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetAppMemoryPercentageMetrics: (appId: string, start: string, end: string, appComponent?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetAppRestartCountMetricsYml: (appId: string, start: string, end: string, appComponent?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetDropletBandwidthMetrics: (hostId: string, _interface: MonitoringGetDropletBandwidthMetricsInterfaceEnum, direction: MonitoringGetDropletBandwidthMetricsDirectionEnum, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetDropletCpuMetrics: (hostId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetDropletFilesystemFreeMetrics: (hostId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetDropletFilesystemSizeMetrics: (hostId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetDropletLoad15Metrics: (hostId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetDropletLoad1Metrics: (hostId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetDropletLoad5Metrics: (hostId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetDropletMemoryAvailableMetrics: (hostId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetDropletMemoryCachedMetrics: (hostId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetDropletMemoryFreeMetrics: (hostId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetDropletMemoryTotalMetrics: (hostId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbDropletsConnections: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbDropletsDowntime: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbDropletsHealthChecks: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbDropletsHttpResponseTime50p: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbDropletsHttpResponseTime95p: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbDropletsHttpResponseTime99p: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbDropletsHttpResponseTimeAvg: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbDropletsHttpResponses: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbDropletsHttpSessionDuration50p: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbDropletsHttpSessionDuration95p: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbDropletsHttpSessionDurationAvg: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbDropletsQueueSize: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbFrontendConnectionsCurrent: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbFrontendConnectionsLimit: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbFrontendCpuUtilization: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbFrontendFirewallDroppedBytes: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbFrontendFirewallDroppedPackets: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbFrontendHttpRequestsPerSecond: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbFrontendHttpResponses: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbFrontendNetworkThroughputHttp: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbFrontendNetworkThroughputTcp: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbFrontendNetworkThroughputUdp: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbFrontendNlbTcpNetworkThroughput: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbFrontendNlbUdpNetworkThroughput: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbFrontendTlsConnectionsCurrent: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbFrontendTlsConnectionsExceedingRateLimit: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringGetLbFrontendTlsConnectionsLimit: (lbId: string, start: string, end: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringListAlertPolicy: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    monitoringUpdateAlertPolicy: (alertUuid: string, alertPolicyRequest: AlertPolicyRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const MonitoringApiFp: (configuration?: Configuration) => {
    monitoringCreateAlertPolicy(alertPolicyRequest: AlertPolicyRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MonitoringCreateAlertPolicy200Response>>;
    monitoringDeleteAlertPolicy(alertUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    monitoringGetAlertPolicy(alertUuid: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MonitoringCreateAlertPolicy200Response>>;
    monitoringGetAppCPUPercentageMetrics(appId: string, start: string, end: string, appComponent?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetAppMemoryPercentageMetrics(appId: string, start: string, end: string, appComponent?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetAppRestartCountMetricsYml(appId: string, start: string, end: string, appComponent?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetDropletBandwidthMetrics(hostId: string, _interface: MonitoringGetDropletBandwidthMetricsInterfaceEnum, direction: MonitoringGetDropletBandwidthMetricsDirectionEnum, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetDropletCpuMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetDropletFilesystemFreeMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetDropletFilesystemSizeMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetDropletLoad15Metrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetDropletLoad1Metrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetDropletLoad5Metrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetDropletMemoryAvailableMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetDropletMemoryCachedMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetDropletMemoryFreeMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetDropletMemoryTotalMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbDropletsConnections(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbDropletsDowntime(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbDropletsHealthChecks(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbDropletsHttpResponseTime50p(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbDropletsHttpResponseTime95p(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbDropletsHttpResponseTime99p(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbDropletsHttpResponseTimeAvg(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbDropletsHttpResponses(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbDropletsHttpSessionDuration50p(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbDropletsHttpSessionDuration95p(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbDropletsHttpSessionDurationAvg(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbDropletsQueueSize(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbFrontendConnectionsCurrent(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbFrontendConnectionsLimit(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbFrontendCpuUtilization(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbFrontendFirewallDroppedBytes(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbFrontendFirewallDroppedPackets(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbFrontendHttpRequestsPerSecond(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbFrontendHttpResponses(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbFrontendNetworkThroughputHttp(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbFrontendNetworkThroughputTcp(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbFrontendNetworkThroughputUdp(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbFrontendNlbTcpNetworkThroughput(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbFrontendNlbUdpNetworkThroughput(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbFrontendTlsConnectionsCurrent(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbFrontendTlsConnectionsExceedingRateLimit(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringGetLbFrontendTlsConnectionsLimit(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Metrics>>;
    monitoringListAlertPolicy(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MonitoringListAlertPolicy200Response>>;
    monitoringUpdateAlertPolicy(alertUuid: string, alertPolicyRequest: AlertPolicyRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MonitoringCreateAlertPolicy200Response>>;
};
export declare const MonitoringApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    monitoringCreateAlertPolicy(alertPolicyRequest: AlertPolicyRequest, options?: RawAxiosRequestConfig): AxiosPromise<MonitoringCreateAlertPolicy200Response>;
    monitoringDeleteAlertPolicy(alertUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    monitoringGetAlertPolicy(alertUuid: string, options?: RawAxiosRequestConfig): AxiosPromise<MonitoringCreateAlertPolicy200Response>;
    monitoringGetAppCPUPercentageMetrics(appId: string, start: string, end: string, appComponent?: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetAppMemoryPercentageMetrics(appId: string, start: string, end: string, appComponent?: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetAppRestartCountMetricsYml(appId: string, start: string, end: string, appComponent?: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetDropletBandwidthMetrics(hostId: string, _interface: MonitoringGetDropletBandwidthMetricsInterfaceEnum, direction: MonitoringGetDropletBandwidthMetricsDirectionEnum, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetDropletCpuMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetDropletFilesystemFreeMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetDropletFilesystemSizeMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetDropletLoad15Metrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetDropletLoad1Metrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetDropletLoad5Metrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetDropletMemoryAvailableMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetDropletMemoryCachedMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetDropletMemoryFreeMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetDropletMemoryTotalMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbDropletsConnections(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbDropletsDowntime(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbDropletsHealthChecks(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbDropletsHttpResponseTime50p(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbDropletsHttpResponseTime95p(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbDropletsHttpResponseTime99p(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbDropletsHttpResponseTimeAvg(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbDropletsHttpResponses(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbDropletsHttpSessionDuration50p(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbDropletsHttpSessionDuration95p(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbDropletsHttpSessionDurationAvg(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbDropletsQueueSize(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbFrontendConnectionsCurrent(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbFrontendConnectionsLimit(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbFrontendCpuUtilization(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbFrontendFirewallDroppedBytes(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbFrontendFirewallDroppedPackets(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbFrontendHttpRequestsPerSecond(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbFrontendHttpResponses(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbFrontendNetworkThroughputHttp(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbFrontendNetworkThroughputTcp(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbFrontendNetworkThroughputUdp(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbFrontendNlbTcpNetworkThroughput(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbFrontendNlbUdpNetworkThroughput(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbFrontendTlsConnectionsCurrent(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbFrontendTlsConnectionsExceedingRateLimit(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringGetLbFrontendTlsConnectionsLimit(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): AxiosPromise<Metrics>;
    monitoringListAlertPolicy(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<MonitoringListAlertPolicy200Response>;
    monitoringUpdateAlertPolicy(alertUuid: string, alertPolicyRequest: AlertPolicyRequest, options?: RawAxiosRequestConfig): AxiosPromise<MonitoringCreateAlertPolicy200Response>;
};
export declare class MonitoringApi extends BaseAPI {
    monitoringCreateAlertPolicy(alertPolicyRequest: AlertPolicyRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<MonitoringCreateAlertPolicy200Response, any>>;
    monitoringDeleteAlertPolicy(alertUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    monitoringGetAlertPolicy(alertUuid: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<MonitoringCreateAlertPolicy200Response, any>>;
    monitoringGetAppCPUPercentageMetrics(appId: string, start: string, end: string, appComponent?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetAppMemoryPercentageMetrics(appId: string, start: string, end: string, appComponent?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetAppRestartCountMetricsYml(appId: string, start: string, end: string, appComponent?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetDropletBandwidthMetrics(hostId: string, _interface: MonitoringGetDropletBandwidthMetricsInterfaceEnum, direction: MonitoringGetDropletBandwidthMetricsDirectionEnum, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetDropletCpuMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetDropletFilesystemFreeMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetDropletFilesystemSizeMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetDropletLoad15Metrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetDropletLoad1Metrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetDropletLoad5Metrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetDropletMemoryAvailableMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetDropletMemoryCachedMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetDropletMemoryFreeMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetDropletMemoryTotalMetrics(hostId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbDropletsConnections(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbDropletsDowntime(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbDropletsHealthChecks(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbDropletsHttpResponseTime50p(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbDropletsHttpResponseTime95p(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbDropletsHttpResponseTime99p(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbDropletsHttpResponseTimeAvg(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbDropletsHttpResponses(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbDropletsHttpSessionDuration50p(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbDropletsHttpSessionDuration95p(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbDropletsHttpSessionDurationAvg(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbDropletsQueueSize(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbFrontendConnectionsCurrent(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbFrontendConnectionsLimit(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbFrontendCpuUtilization(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbFrontendFirewallDroppedBytes(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbFrontendFirewallDroppedPackets(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbFrontendHttpRequestsPerSecond(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbFrontendHttpResponses(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbFrontendNetworkThroughputHttp(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbFrontendNetworkThroughputTcp(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbFrontendNetworkThroughputUdp(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbFrontendNlbTcpNetworkThroughput(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbFrontendNlbUdpNetworkThroughput(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbFrontendTlsConnectionsCurrent(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbFrontendTlsConnectionsExceedingRateLimit(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringGetLbFrontendTlsConnectionsLimit(lbId: string, start: string, end: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<Metrics, any>>;
    monitoringListAlertPolicy(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<MonitoringListAlertPolicy200Response, any>>;
    monitoringUpdateAlertPolicy(alertUuid: string, alertPolicyRequest: AlertPolicyRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<MonitoringCreateAlertPolicy200Response, any>>;
}
export declare const MonitoringGetDropletBandwidthMetricsInterfaceEnum: {
    readonly Private: "private";
    readonly Public: "public";
};
export type MonitoringGetDropletBandwidthMetricsInterfaceEnum = (typeof MonitoringGetDropletBandwidthMetricsInterfaceEnum)[keyof typeof MonitoringGetDropletBandwidthMetricsInterfaceEnum];
export declare const MonitoringGetDropletBandwidthMetricsDirectionEnum: {
    readonly Inbound: "inbound";
    readonly Outbound: "outbound";
};
export type MonitoringGetDropletBandwidthMetricsDirectionEnum = (typeof MonitoringGetDropletBandwidthMetricsDirectionEnum)[keyof typeof MonitoringGetDropletBandwidthMetricsDirectionEnum];
export declare const ProjectResourcesApiAxiosParamCreator: (configuration?: Configuration) => {
    projectsAssignResources: (projectId: string, projectAssignment: ProjectAssignment, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    projectsAssignResourcesDefault: (projectAssignment: ProjectAssignment, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    projectsListResources: (projectId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    projectsListResourcesDefault: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const ProjectResourcesApiFp: (configuration?: Configuration) => {
    projectsAssignResources(projectId: string, projectAssignment: ProjectAssignment, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProjectsAssignResources200Response>>;
    projectsAssignResourcesDefault(projectAssignment: ProjectAssignment, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProjectsAssignResources200Response>>;
    projectsListResources(projectId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProjectsListResources200Response>>;
    projectsListResourcesDefault(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProjectsListResources200Response>>;
};
export declare const ProjectResourcesApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    projectsAssignResources(projectId: string, projectAssignment: ProjectAssignment, options?: RawAxiosRequestConfig): AxiosPromise<ProjectsAssignResources200Response>;
    projectsAssignResourcesDefault(projectAssignment: ProjectAssignment, options?: RawAxiosRequestConfig): AxiosPromise<ProjectsAssignResources200Response>;
    projectsListResources(projectId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<ProjectsListResources200Response>;
    projectsListResourcesDefault(options?: RawAxiosRequestConfig): AxiosPromise<ProjectsListResources200Response>;
};
export declare class ProjectResourcesApi extends BaseAPI {
    projectsAssignResources(projectId: string, projectAssignment: ProjectAssignment, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ProjectsAssignResources200Response, any>>;
    projectsAssignResourcesDefault(projectAssignment: ProjectAssignment, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ProjectsAssignResources200Response, any>>;
    projectsListResources(projectId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ProjectsListResources200Response, any>>;
    projectsListResourcesDefault(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ProjectsListResources200Response, any>>;
}
export declare const ProjectsApiAxiosParamCreator: (configuration?: Configuration) => {
    projectsCreate: (projectBase: ProjectBase, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    projectsDelete: (projectId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    projectsGet: (projectId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    projectsGetDefault: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    projectsList: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    projectsPatch: (projectId: string, project: Project, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    projectsPatchDefault: (project: Project, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    projectsUpdate: (projectId: string, project: Project, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    projectsUpdateDefault: (project: Project, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const ProjectsApiFp: (configuration?: Configuration) => {
    projectsCreate(projectBase: ProjectBase, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProjectsCreate201Response>>;
    projectsDelete(projectId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    projectsGet(projectId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProjectsCreate201Response>>;
    projectsGetDefault(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProjectsGetDefault200Response>>;
    projectsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProjectsList200Response>>;
    projectsPatch(projectId: string, project: Project, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProjectsCreate201Response>>;
    projectsPatchDefault(project: Project, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProjectsCreate201Response>>;
    projectsUpdate(projectId: string, project: Project, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProjectsCreate201Response>>;
    projectsUpdateDefault(project: Project, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ProjectsCreate201Response>>;
};
export declare const ProjectsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    projectsCreate(projectBase: ProjectBase, options?: RawAxiosRequestConfig): AxiosPromise<ProjectsCreate201Response>;
    projectsDelete(projectId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    projectsGet(projectId: string, options?: RawAxiosRequestConfig): AxiosPromise<ProjectsCreate201Response>;
    projectsGetDefault(options?: RawAxiosRequestConfig): AxiosPromise<ProjectsGetDefault200Response>;
    projectsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<ProjectsList200Response>;
    projectsPatch(projectId: string, project: Project, options?: RawAxiosRequestConfig): AxiosPromise<ProjectsCreate201Response>;
    projectsPatchDefault(project: Project, options?: RawAxiosRequestConfig): AxiosPromise<ProjectsCreate201Response>;
    projectsUpdate(projectId: string, project: Project, options?: RawAxiosRequestConfig): AxiosPromise<ProjectsCreate201Response>;
    projectsUpdateDefault(project: Project, options?: RawAxiosRequestConfig): AxiosPromise<ProjectsCreate201Response>;
};
export declare class ProjectsApi extends BaseAPI {
    projectsCreate(projectBase: ProjectBase, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ProjectsCreate201Response, any>>;
    projectsDelete(projectId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    projectsGet(projectId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ProjectsCreate201Response, any>>;
    projectsGetDefault(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ProjectsGetDefault200Response, any>>;
    projectsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ProjectsList200Response, any>>;
    projectsPatch(projectId: string, project: Project, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ProjectsCreate201Response, any>>;
    projectsPatchDefault(project: Project, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ProjectsCreate201Response, any>>;
    projectsUpdate(projectId: string, project: Project, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ProjectsCreate201Response, any>>;
    projectsUpdateDefault(project: Project, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ProjectsCreate201Response, any>>;
}
export declare const RegionsApiAxiosParamCreator: (configuration?: Configuration) => {
    regionsList: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const RegionsApiFp: (configuration?: Configuration) => {
    regionsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<RegionsList200Response>>;
};
export declare const RegionsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    regionsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<RegionsList200Response>;
};
export declare class RegionsApi extends BaseAPI {
    regionsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<RegionsList200Response, any>>;
}
export declare const ReservedIPActionsApiAxiosParamCreator: (configuration?: Configuration) => {
    reservedIPsActionsGet: (reservedIp: string, actionId: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    reservedIPsActionsList: (reservedIp: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    reservedIPsActionsPost: (reservedIp: string, reservedIPsActionsPostRequest?: ReservedIPsActionsPostRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const ReservedIPActionsApiFp: (configuration?: Configuration) => {
    reservedIPsActionsGet(reservedIp: string, actionId: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ReservedIPsActionsPost201Response>>;
    reservedIPsActionsList(reservedIp: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ReservedIPsActionsList200Response>>;
    reservedIPsActionsPost(reservedIp: string, reservedIPsActionsPostRequest?: ReservedIPsActionsPostRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ReservedIPsActionsPost201Response>>;
};
export declare const ReservedIPActionsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    reservedIPsActionsGet(reservedIp: string, actionId: number, options?: RawAxiosRequestConfig): AxiosPromise<ReservedIPsActionsPost201Response>;
    reservedIPsActionsList(reservedIp: string, options?: RawAxiosRequestConfig): AxiosPromise<ReservedIPsActionsList200Response>;
    reservedIPsActionsPost(reservedIp: string, reservedIPsActionsPostRequest?: ReservedIPsActionsPostRequest, options?: RawAxiosRequestConfig): AxiosPromise<ReservedIPsActionsPost201Response>;
};
export declare class ReservedIPActionsApi extends BaseAPI {
    reservedIPsActionsGet(reservedIp: string, actionId: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ReservedIPsActionsPost201Response, any>>;
    reservedIPsActionsList(reservedIp: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ReservedIPsActionsList200Response, any>>;
    reservedIPsActionsPost(reservedIp: string, reservedIPsActionsPostRequest?: ReservedIPsActionsPostRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ReservedIPsActionsPost201Response, any>>;
}
export declare const ReservedIPsApiAxiosParamCreator: (configuration?: Configuration) => {
    reservedIPsCreate: (reservedIpCreate: ReservedIpCreate, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    reservedIPsDelete: (reservedIp: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    reservedIPsGet: (reservedIp: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    reservedIPsList: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const ReservedIPsApiFp: (configuration?: Configuration) => {
    reservedIPsCreate(reservedIpCreate: ReservedIpCreate, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ReservedIPsCreate202Response>>;
    reservedIPsDelete(reservedIp: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    reservedIPsGet(reservedIp: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ReservedIPsGet200Response>>;
    reservedIPsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ReservedIPsList200Response>>;
};
export declare const ReservedIPsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    reservedIPsCreate(reservedIpCreate: ReservedIpCreate, options?: RawAxiosRequestConfig): AxiosPromise<ReservedIPsCreate202Response>;
    reservedIPsDelete(reservedIp: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    reservedIPsGet(reservedIp: string, options?: RawAxiosRequestConfig): AxiosPromise<ReservedIPsGet200Response>;
    reservedIPsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<ReservedIPsList200Response>;
};
export declare class ReservedIPsApi extends BaseAPI {
    reservedIPsCreate(reservedIpCreate: ReservedIpCreate, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ReservedIPsCreate202Response, any>>;
    reservedIPsDelete(reservedIp: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    reservedIPsGet(reservedIp: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ReservedIPsGet200Response, any>>;
    reservedIPsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ReservedIPsList200Response, any>>;
}
export declare const SSHKeysApiAxiosParamCreator: (configuration?: Configuration) => {
    sshKeysCreate: (sshKeys: SshKeys, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    sshKeysDelete: (sshKeyIdentifier: SshKeysGetSshKeyIdentifierParameter, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    sshKeysGet: (sshKeyIdentifier: SshKeysGetSshKeyIdentifierParameter, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    sshKeysList: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    sshKeysUpdate: (sshKeyIdentifier: SshKeysGetSshKeyIdentifierParameter, sshKeysUpdateRequest: SshKeysUpdateRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const SSHKeysApiFp: (configuration?: Configuration) => {
    sshKeysCreate(sshKeys: SshKeys, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<SshKeysCreate201Response>>;
    sshKeysDelete(sshKeyIdentifier: SshKeysGetSshKeyIdentifierParameter, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    sshKeysGet(sshKeyIdentifier: SshKeysGetSshKeyIdentifierParameter, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<SshKeysCreate201Response>>;
    sshKeysList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<SshKeysList200Response>>;
    sshKeysUpdate(sshKeyIdentifier: SshKeysGetSshKeyIdentifierParameter, sshKeysUpdateRequest: SshKeysUpdateRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<SshKeysCreate201Response>>;
};
export declare const SSHKeysApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    sshKeysCreate(sshKeys: SshKeys, options?: RawAxiosRequestConfig): AxiosPromise<SshKeysCreate201Response>;
    sshKeysDelete(sshKeyIdentifier: SshKeysGetSshKeyIdentifierParameter, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    sshKeysGet(sshKeyIdentifier: SshKeysGetSshKeyIdentifierParameter, options?: RawAxiosRequestConfig): AxiosPromise<SshKeysCreate201Response>;
    sshKeysList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<SshKeysList200Response>;
    sshKeysUpdate(sshKeyIdentifier: SshKeysGetSshKeyIdentifierParameter, sshKeysUpdateRequest: SshKeysUpdateRequest, options?: RawAxiosRequestConfig): AxiosPromise<SshKeysCreate201Response>;
};
export declare class SSHKeysApi extends BaseAPI {
    sshKeysCreate(sshKeys: SshKeys, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<SshKeysCreate201Response, any>>;
    sshKeysDelete(sshKeyIdentifier: SshKeysGetSshKeyIdentifierParameter, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    sshKeysGet(sshKeyIdentifier: SshKeysGetSshKeyIdentifierParameter, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<SshKeysCreate201Response, any>>;
    sshKeysList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<SshKeysList200Response, any>>;
    sshKeysUpdate(sshKeyIdentifier: SshKeysGetSshKeyIdentifierParameter, sshKeysUpdateRequest: SshKeysUpdateRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<SshKeysCreate201Response, any>>;
}
export declare const SizesApiAxiosParamCreator: (configuration?: Configuration) => {
    sizesList: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const SizesApiFp: (configuration?: Configuration) => {
    sizesList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<SizesList200Response>>;
};
export declare const SizesApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    sizesList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<SizesList200Response>;
};
export declare class SizesApi extends BaseAPI {
    sizesList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<SizesList200Response, any>>;
}
export declare const SnapshotsApiAxiosParamCreator: (configuration?: Configuration) => {
    snapshotsDelete: (snapshotId: SnapshotsGetSnapshotIdParameter, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    snapshotsGet: (snapshotId: SnapshotsGetSnapshotIdParameter, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    snapshotsList: (perPage?: number, page?: number, resourceType?: SnapshotsListResourceTypeEnum, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const SnapshotsApiFp: (configuration?: Configuration) => {
    snapshotsDelete(snapshotId: SnapshotsGetSnapshotIdParameter, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    snapshotsGet(snapshotId: SnapshotsGetSnapshotIdParameter, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<SnapshotsGet200Response>>;
    snapshotsList(perPage?: number, page?: number, resourceType?: SnapshotsListResourceTypeEnum, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<SnapshotsList200Response>>;
};
export declare const SnapshotsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    snapshotsDelete(snapshotId: SnapshotsGetSnapshotIdParameter, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    snapshotsGet(snapshotId: SnapshotsGetSnapshotIdParameter, options?: RawAxiosRequestConfig): AxiosPromise<SnapshotsGet200Response>;
    snapshotsList(perPage?: number, page?: number, resourceType?: SnapshotsListResourceTypeEnum, options?: RawAxiosRequestConfig): AxiosPromise<SnapshotsList200Response>;
};
export declare class SnapshotsApi extends BaseAPI {
    snapshotsDelete(snapshotId: SnapshotsGetSnapshotIdParameter, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    snapshotsGet(snapshotId: SnapshotsGetSnapshotIdParameter, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<SnapshotsGet200Response, any>>;
    snapshotsList(perPage?: number, page?: number, resourceType?: SnapshotsListResourceTypeEnum, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<SnapshotsList200Response, any>>;
}
export declare const SnapshotsListResourceTypeEnum: {
    readonly Droplet: "droplet";
    readonly Volume: "volume";
};
export type SnapshotsListResourceTypeEnum = (typeof SnapshotsListResourceTypeEnum)[keyof typeof SnapshotsListResourceTypeEnum];
export declare const TagsApiAxiosParamCreator: (configuration?: Configuration) => {
    tagsAssignResources: (tagId: string, tagsResource: TagsResource, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    tagsCreate: (tags: Tags, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    tagsDelete: (tagId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    tagsGet: (tagId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    tagsList: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    tagsUnassignResources: (tagId: string, tagsResource: TagsResource, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const TagsApiFp: (configuration?: Configuration) => {
    tagsAssignResources(tagId: string, tagsResource: TagsResource, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    tagsCreate(tags: Tags, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<TagsCreate201Response>>;
    tagsDelete(tagId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    tagsGet(tagId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<TagsGet200Response>>;
    tagsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<TagsList200Response>>;
    tagsUnassignResources(tagId: string, tagsResource: TagsResource, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
};
export declare const TagsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    tagsAssignResources(tagId: string, tagsResource: TagsResource, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    tagsCreate(tags: Tags, options?: RawAxiosRequestConfig): AxiosPromise<TagsCreate201Response>;
    tagsDelete(tagId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    tagsGet(tagId: string, options?: RawAxiosRequestConfig): AxiosPromise<TagsGet200Response>;
    tagsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<TagsList200Response>;
    tagsUnassignResources(tagId: string, tagsResource: TagsResource, options?: RawAxiosRequestConfig): AxiosPromise<void>;
};
export declare class TagsApi extends BaseAPI {
    tagsAssignResources(tagId: string, tagsResource: TagsResource, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    tagsCreate(tags: Tags, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<TagsCreate201Response, any>>;
    tagsDelete(tagId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    tagsGet(tagId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<TagsGet200Response, any>>;
    tagsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<TagsList200Response, any>>;
    tagsUnassignResources(tagId: string, tagsResource: TagsResource, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
}
export declare const UptimeApiAxiosParamCreator: (configuration?: Configuration) => {
    uptimeCreateAlert: (checkId: string, alert: Alert, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    uptimeCreateCheck: (checkUpdatable: CheckUpdatable, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    uptimeDeleteAlert: (checkId: string, alertId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    uptimeDeleteCheck: (checkId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    uptimeGetAlert: (checkId: string, alertId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    uptimeGetCheck: (checkId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    uptimeGetCheckState: (checkId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    uptimeListAlerts: (checkId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    uptimeListChecks: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    uptimeUpdateAlert: (checkId: string, alertId: string, alertUpdatable: AlertUpdatable, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    uptimeUpdateCheck: (checkId: string, checkUpdatable: CheckUpdatable, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const UptimeApiFp: (configuration?: Configuration) => {
    uptimeCreateAlert(checkId: string, alert: Alert, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<UptimeCreateAlert201Response>>;
    uptimeCreateCheck(checkUpdatable: CheckUpdatable, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<UptimeCreateCheck201Response>>;
    uptimeDeleteAlert(checkId: string, alertId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    uptimeDeleteCheck(checkId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    uptimeGetAlert(checkId: string, alertId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<UptimeCreateAlert201Response>>;
    uptimeGetCheck(checkId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<UptimeCreateCheck201Response>>;
    uptimeGetCheckState(checkId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<UptimeGetCheckState200Response>>;
    uptimeListAlerts(checkId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<UptimeListAlerts200Response>>;
    uptimeListChecks(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<UptimeListChecks200Response>>;
    uptimeUpdateAlert(checkId: string, alertId: string, alertUpdatable: AlertUpdatable, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<UptimeCreateAlert201Response>>;
    uptimeUpdateCheck(checkId: string, checkUpdatable: CheckUpdatable, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<UptimeCreateCheck201Response>>;
};
export declare const UptimeApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    uptimeCreateAlert(checkId: string, alert: Alert, options?: RawAxiosRequestConfig): AxiosPromise<UptimeCreateAlert201Response>;
    uptimeCreateCheck(checkUpdatable: CheckUpdatable, options?: RawAxiosRequestConfig): AxiosPromise<UptimeCreateCheck201Response>;
    uptimeDeleteAlert(checkId: string, alertId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    uptimeDeleteCheck(checkId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    uptimeGetAlert(checkId: string, alertId: string, options?: RawAxiosRequestConfig): AxiosPromise<UptimeCreateAlert201Response>;
    uptimeGetCheck(checkId: string, options?: RawAxiosRequestConfig): AxiosPromise<UptimeCreateCheck201Response>;
    uptimeGetCheckState(checkId: string, options?: RawAxiosRequestConfig): AxiosPromise<UptimeGetCheckState200Response>;
    uptimeListAlerts(checkId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<UptimeListAlerts200Response>;
    uptimeListChecks(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<UptimeListChecks200Response>;
    uptimeUpdateAlert(checkId: string, alertId: string, alertUpdatable: AlertUpdatable, options?: RawAxiosRequestConfig): AxiosPromise<UptimeCreateAlert201Response>;
    uptimeUpdateCheck(checkId: string, checkUpdatable: CheckUpdatable, options?: RawAxiosRequestConfig): AxiosPromise<UptimeCreateCheck201Response>;
};
export declare class UptimeApi extends BaseAPI {
    uptimeCreateAlert(checkId: string, alert: Alert, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<UptimeCreateAlert201Response, any>>;
    uptimeCreateCheck(checkUpdatable: CheckUpdatable, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<UptimeCreateCheck201Response, any>>;
    uptimeDeleteAlert(checkId: string, alertId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    uptimeDeleteCheck(checkId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    uptimeGetAlert(checkId: string, alertId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<UptimeCreateAlert201Response, any>>;
    uptimeGetCheck(checkId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<UptimeCreateCheck201Response, any>>;
    uptimeGetCheckState(checkId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<UptimeGetCheckState200Response, any>>;
    uptimeListAlerts(checkId: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<UptimeListAlerts200Response, any>>;
    uptimeListChecks(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<UptimeListChecks200Response, any>>;
    uptimeUpdateAlert(checkId: string, alertId: string, alertUpdatable: AlertUpdatable, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<UptimeCreateAlert201Response, any>>;
    uptimeUpdateCheck(checkId: string, checkUpdatable: CheckUpdatable, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<UptimeCreateCheck201Response, any>>;
}
export declare const VPCsApiAxiosParamCreator: (configuration?: Configuration) => {
    vpcsCreate: (vpcsCreateRequest: VpcsCreateRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    vpcsDelete: (vpcId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    vpcsGet: (vpcId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    vpcsList: (perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    vpcsListMembers: (vpcId: string, resourceType?: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    vpcsPatch: (vpcId: string, vpcsPatchRequest: VpcsPatchRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
    vpcsUpdate: (vpcId: string, vpcsUpdateRequest: VpcsUpdateRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
};
export declare const VPCsApiFp: (configuration?: Configuration) => {
    vpcsCreate(vpcsCreateRequest: VpcsCreateRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VpcsCreate201Response>>;
    vpcsDelete(vpcId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
    vpcsGet(vpcId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VpcsCreate201Response>>;
    vpcsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VpcsList200Response>>;
    vpcsListMembers(vpcId: string, resourceType?: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VpcsListMembers200Response>>;
    vpcsPatch(vpcId: string, vpcsPatchRequest: VpcsPatchRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VpcsCreate201Response>>;
    vpcsUpdate(vpcId: string, vpcsUpdateRequest: VpcsUpdateRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<VpcsCreate201Response>>;
};
export declare const VPCsApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
    vpcsCreate(vpcsCreateRequest: VpcsCreateRequest, options?: RawAxiosRequestConfig): AxiosPromise<VpcsCreate201Response>;
    vpcsDelete(vpcId: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
    vpcsGet(vpcId: string, options?: RawAxiosRequestConfig): AxiosPromise<VpcsCreate201Response>;
    vpcsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<VpcsList200Response>;
    vpcsListMembers(vpcId: string, resourceType?: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): AxiosPromise<VpcsListMembers200Response>;
    vpcsPatch(vpcId: string, vpcsPatchRequest: VpcsPatchRequest, options?: RawAxiosRequestConfig): AxiosPromise<VpcsCreate201Response>;
    vpcsUpdate(vpcId: string, vpcsUpdateRequest: VpcsUpdateRequest, options?: RawAxiosRequestConfig): AxiosPromise<VpcsCreate201Response>;
};
export declare class VPCsApi extends BaseAPI {
    vpcsCreate(vpcsCreateRequest: VpcsCreateRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VpcsCreate201Response, any>>;
    vpcsDelete(vpcId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any>>;
    vpcsGet(vpcId: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VpcsCreate201Response, any>>;
    vpcsList(perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VpcsList200Response, any>>;
    vpcsListMembers(vpcId: string, resourceType?: string, perPage?: number, page?: number, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VpcsListMembers200Response, any>>;
    vpcsPatch(vpcId: string, vpcsPatchRequest: VpcsPatchRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VpcsCreate201Response, any>>;
    vpcsUpdate(vpcId: string, vpcsUpdateRequest: VpcsUpdateRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<VpcsCreate201Response, any>>;
}
