export type ClientOptions = {
    baseUrl: "https://your-dokploy-instance.com/api" | (string & {});
};
/**
 * Invalid input data error (400)
 *
 * The error information
 */
export type ErrorBadRequest = {
    /**
     * The error message
     */
    message: string;
    /**
     * The error code
     */
    code: string;
    /**
     * An array of issues that were responsible for the error
     */
    issues?: Array<{
        message: string;
    }>;
};
/**
 * Authorization not provided error (401)
 *
 * The error information
 */
export type ErrorUnauthorized = {
    /**
     * The error message
     */
    message: string;
    /**
     * The error code
     */
    code: string;
    /**
     * An array of issues that were responsible for the error
     */
    issues?: Array<{
        message: string;
    }>;
};
/**
 * Insufficient access error (403)
 *
 * The error information
 */
export type ErrorForbidden = {
    /**
     * The error message
     */
    message: string;
    /**
     * The error code
     */
    code: string;
    /**
     * An array of issues that were responsible for the error
     */
    issues?: Array<{
        message: string;
    }>;
};
/**
 * Internal server error error (500)
 *
 * The error information
 */
export type ErrorInternalServerError = {
    /**
     * The error message
     */
    message: string;
    /**
     * The error code
     */
    code: string;
    /**
     * An array of issues that were responsible for the error
     */
    issues?: Array<{
        message: string;
    }>;
};
/**
 * Not found error (404)
 *
 * The error information
 */
export type ErrorNotFound = {
    /**
     * The error message
     */
    message: string;
    /**
     * The error code
     */
    code: string;
    /**
     * An array of issues that were responsible for the error
     */
    issues?: Array<{
        message: string;
    }>;
};
export type AdminSetupMonitoringData = {
    body: {
        metricsConfig: {
            server: {
                refreshRate: number;
                port: number;
                token: string;
                urlCallback: string;
                retentionDays: number;
                cronJob: string;
                thresholds: {
                    cpu: number;
                    memory: number;
                };
            };
            containers: {
                refreshRate: number;
                services: {
                    include?: Array<string>;
                    exclude?: Array<string>;
                };
            };
        };
    };
    path?: never;
    query?: never;
    url: "/admin.setupMonitoring";
};
export type AdminSetupMonitoringErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AdminSetupMonitoringError = AdminSetupMonitoringErrors[keyof AdminSetupMonitoringErrors];
export type AdminSetupMonitoringResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AdminSetupMonitoringResponse = AdminSetupMonitoringResponses[keyof AdminSetupMonitoringResponses];
export type ApplicationCreateData = {
    body: {
        name: string;
        appName?: string;
        description?: string | null;
        environmentId: string;
        serverId?: string | null;
        sourceType?: "github" | "docker" | "git" | "gitlab" | "bitbucket" | "gitea" | "drop";
    };
    path?: never;
    query?: never;
    url: "/application.create";
};
export type ApplicationCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationCreateError = ApplicationCreateErrors[keyof ApplicationCreateErrors];
export type ApplicationCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationCreateResponse = ApplicationCreateResponses[keyof ApplicationCreateResponses];
export type ApplicationDeployNginxQuickstartData = {
    body: {
        environmentId: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/application.deployNginxQuickstart";
};
export type ApplicationDeployNginxQuickstartErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationDeployNginxQuickstartError = ApplicationDeployNginxQuickstartErrors[keyof ApplicationDeployNginxQuickstartErrors];
export type ApplicationDeployNginxQuickstartResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationDeployNginxQuickstartResponse = ApplicationDeployNginxQuickstartResponses[keyof ApplicationDeployNginxQuickstartResponses];
export type ApplicationOneData = {
    body?: never;
    path?: never;
    query: {
        applicationId: string;
    };
    url: "/application.one";
};
export type ApplicationOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationOneError = ApplicationOneErrors[keyof ApplicationOneErrors];
export type ApplicationOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationOneResponse = ApplicationOneResponses[keyof ApplicationOneResponses];
export type ApplicationReloadData = {
    body: {
        appName: string;
        applicationId: string;
    };
    path?: never;
    query?: never;
    url: "/application.reload";
};
export type ApplicationReloadErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationReloadError = ApplicationReloadErrors[keyof ApplicationReloadErrors];
export type ApplicationReloadResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationReloadResponse = ApplicationReloadResponses[keyof ApplicationReloadResponses];
export type ApplicationDeleteData = {
    body: {
        applicationId: string;
    };
    path?: never;
    query?: never;
    url: "/application.delete";
};
export type ApplicationDeleteErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationDeleteError = ApplicationDeleteErrors[keyof ApplicationDeleteErrors];
export type ApplicationDeleteResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationDeleteResponse = ApplicationDeleteResponses[keyof ApplicationDeleteResponses];
export type ApplicationStopData = {
    body: {
        applicationId: string;
    };
    path?: never;
    query?: never;
    url: "/application.stop";
};
export type ApplicationStopErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationStopError = ApplicationStopErrors[keyof ApplicationStopErrors];
export type ApplicationStopResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationStopResponse = ApplicationStopResponses[keyof ApplicationStopResponses];
export type ApplicationStartData = {
    body: {
        applicationId: string;
    };
    path?: never;
    query?: never;
    url: "/application.start";
};
export type ApplicationStartErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationStartError = ApplicationStartErrors[keyof ApplicationStartErrors];
export type ApplicationStartResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationStartResponse = ApplicationStartResponses[keyof ApplicationStartResponses];
export type ApplicationRedeployData = {
    body: {
        applicationId: string;
        title?: string;
        description?: string;
    };
    path?: never;
    query?: never;
    url: "/application.redeploy";
};
export type ApplicationRedeployErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationRedeployError = ApplicationRedeployErrors[keyof ApplicationRedeployErrors];
export type ApplicationRedeployResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationRedeployResponse = ApplicationRedeployResponses[keyof ApplicationRedeployResponses];
export type ApplicationSaveEnvironmentData = {
    body: {
        applicationId: string;
        env: string | null;
        buildArgs: string | null;
        buildSecrets: string | null;
        createEnvFile: boolean;
    };
    path?: never;
    query?: never;
    url: "/application.saveEnvironment";
};
export type ApplicationSaveEnvironmentErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationSaveEnvironmentError = ApplicationSaveEnvironmentErrors[keyof ApplicationSaveEnvironmentErrors];
export type ApplicationSaveEnvironmentResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationSaveEnvironmentResponse = ApplicationSaveEnvironmentResponses[keyof ApplicationSaveEnvironmentResponses];
export type ApplicationSaveBuildTypeData = {
    body: {
        applicationId: string;
        buildType: "dockerfile" | "heroku_buildpacks" | "paketo_buildpacks" | "nixpacks" | "static" | "railpack";
        dockerfile: string | null;
        dockerContextPath: string | null;
        dockerBuildStage: string | null;
        herokuVersion: string | null;
        railpackVersion: string | null;
        publishDirectory?: string | null;
        isStaticSpa?: boolean | null;
    };
    path?: never;
    query?: never;
    url: "/application.saveBuildType";
};
export type ApplicationSaveBuildTypeErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationSaveBuildTypeError = ApplicationSaveBuildTypeErrors[keyof ApplicationSaveBuildTypeErrors];
export type ApplicationSaveBuildTypeResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationSaveBuildTypeResponse = ApplicationSaveBuildTypeResponses[keyof ApplicationSaveBuildTypeResponses];
export type ApplicationSaveGithubProviderData = {
    body: {
        applicationId: string;
        repository: string | null;
        owner: string | null;
        buildPath: string | null;
        githubId: string | null;
        branch: string;
        triggerType: "push" | "tag";
        enableSubmodules?: boolean;
        watchPaths?: Array<string> | null;
    };
    path?: never;
    query?: never;
    url: "/application.saveGithubProvider";
};
export type ApplicationSaveGithubProviderErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationSaveGithubProviderError = ApplicationSaveGithubProviderErrors[keyof ApplicationSaveGithubProviderErrors];
export type ApplicationSaveGithubProviderResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationSaveGithubProviderResponse = ApplicationSaveGithubProviderResponses[keyof ApplicationSaveGithubProviderResponses];
export type ApplicationSaveGitlabProviderData = {
    body: {
        applicationId: string;
        gitlabBuildPath: string | null;
        gitlabOwner: string | null;
        gitlabRepository: string | null;
        gitlabId: string | null;
        gitlabProjectId: number | null;
        gitlabPathNamespace: string | null;
        gitlabBranch: string;
        enableSubmodules?: boolean;
        watchPaths?: Array<string> | null;
    };
    path?: never;
    query?: never;
    url: "/application.saveGitlabProvider";
};
export type ApplicationSaveGitlabProviderErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationSaveGitlabProviderError = ApplicationSaveGitlabProviderErrors[keyof ApplicationSaveGitlabProviderErrors];
export type ApplicationSaveGitlabProviderResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationSaveGitlabProviderResponse = ApplicationSaveGitlabProviderResponses[keyof ApplicationSaveGitlabProviderResponses];
export type ApplicationSaveBitbucketProviderData = {
    body: {
        bitbucketBuildPath: string | null;
        bitbucketOwner: string | null;
        bitbucketRepository: string | null;
        bitbucketRepositorySlug: string | null;
        bitbucketId: string | null;
        applicationId: string;
        bitbucketBranch: string;
        enableSubmodules?: boolean;
        watchPaths?: Array<string> | null;
    };
    path?: never;
    query?: never;
    url: "/application.saveBitbucketProvider";
};
export type ApplicationSaveBitbucketProviderErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationSaveBitbucketProviderError = ApplicationSaveBitbucketProviderErrors[keyof ApplicationSaveBitbucketProviderErrors];
export type ApplicationSaveBitbucketProviderResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationSaveBitbucketProviderResponse = ApplicationSaveBitbucketProviderResponses[keyof ApplicationSaveBitbucketProviderResponses];
export type ApplicationSaveGiteaProviderData = {
    body: {
        applicationId: string;
        giteaBuildPath: string | null;
        giteaOwner: string | null;
        giteaRepository: string | null;
        giteaId: string | null;
        giteaBranch: string;
        enableSubmodules?: boolean;
        watchPaths?: Array<string> | null;
    };
    path?: never;
    query?: never;
    url: "/application.saveGiteaProvider";
};
export type ApplicationSaveGiteaProviderErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationSaveGiteaProviderError = ApplicationSaveGiteaProviderErrors[keyof ApplicationSaveGiteaProviderErrors];
export type ApplicationSaveGiteaProviderResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationSaveGiteaProviderResponse = ApplicationSaveGiteaProviderResponses[keyof ApplicationSaveGiteaProviderResponses];
export type ApplicationSaveDockerProviderData = {
    body: {
        dockerImage: string | null;
        applicationId: string;
        username: string | null;
        password: string | null;
        registryUrl: string | null;
    };
    path?: never;
    query?: never;
    url: "/application.saveDockerProvider";
};
export type ApplicationSaveDockerProviderErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationSaveDockerProviderError = ApplicationSaveDockerProviderErrors[keyof ApplicationSaveDockerProviderErrors];
export type ApplicationSaveDockerProviderResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationSaveDockerProviderResponse = ApplicationSaveDockerProviderResponses[keyof ApplicationSaveDockerProviderResponses];
export type ApplicationSaveGitProviderData = {
    body: {
        applicationId: string;
        customGitBuildPath: string | null;
        customGitUrl: string | null;
        watchPaths: Array<string> | null;
        enableSubmodules?: boolean;
        customGitBranch: string;
        customGitSSHKeyId?: string | null;
    };
    path?: never;
    query?: never;
    url: "/application.saveGitProvider";
};
export type ApplicationSaveGitProviderErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationSaveGitProviderError = ApplicationSaveGitProviderErrors[keyof ApplicationSaveGitProviderErrors];
export type ApplicationSaveGitProviderResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationSaveGitProviderResponse = ApplicationSaveGitProviderResponses[keyof ApplicationSaveGitProviderResponses];
export type ApplicationDisconnectGitProviderData = {
    body: {
        applicationId: string;
    };
    path?: never;
    query?: never;
    url: "/application.disconnectGitProvider";
};
export type ApplicationDisconnectGitProviderErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationDisconnectGitProviderError = ApplicationDisconnectGitProviderErrors[keyof ApplicationDisconnectGitProviderErrors];
export type ApplicationDisconnectGitProviderResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationDisconnectGitProviderResponse = ApplicationDisconnectGitProviderResponses[keyof ApplicationDisconnectGitProviderResponses];
export type ApplicationMarkRunningData = {
    body: {
        applicationId: string;
    };
    path?: never;
    query?: never;
    url: "/application.markRunning";
};
export type ApplicationMarkRunningErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationMarkRunningError = ApplicationMarkRunningErrors[keyof ApplicationMarkRunningErrors];
export type ApplicationMarkRunningResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationMarkRunningResponse = ApplicationMarkRunningResponses[keyof ApplicationMarkRunningResponses];
export type ApplicationUpdateData = {
    body: {
        applicationId: string;
        name?: string;
        appName?: string;
        description?: string | null;
        env?: string | null;
        previewEnv?: string | null;
        watchPaths?: Array<string> | null;
        previewBuildArgs?: string | null;
        previewBuildSecrets?: string | null;
        previewLabels?: Array<string> | null;
        previewWildcard?: string | null;
        previewPort?: number | null;
        previewHttps?: boolean;
        previewPath?: string | null;
        previewCertificateType?: "letsencrypt" | "none" | "custom";
        previewCustomCertResolver?: string | null;
        previewLimit?: number | null;
        isPreviewDeploymentsActive?: boolean | null;
        previewRequireCollaboratorPermissions?: boolean | null;
        rollbackActive?: boolean | null;
        buildArgs?: string | null;
        buildSecrets?: string | null;
        memoryReservation?: string | null;
        memoryLimit?: string | null;
        cpuReservation?: string | null;
        cpuLimit?: string | null;
        title?: string | null;
        enabled?: boolean | null;
        subtitle?: string | null;
        command?: string | null;
        args?: Array<string> | null;
        icon?: string | null | null;
        refreshToken?: string | null;
        sourceType?: "github" | "docker" | "git" | "gitlab" | "bitbucket" | "gitea" | "drop";
        cleanCache?: boolean | null;
        repository?: string | null;
        owner?: string | null;
        branch?: string | null;
        buildPath?: string | null;
        triggerType?: "push" | "tag" | null;
        autoDeploy?: boolean | null;
        gitlabProjectId?: number | null;
        gitlabRepository?: string | null;
        gitlabOwner?: string | null;
        gitlabBranch?: string | null;
        gitlabBuildPath?: string | null;
        gitlabPathNamespace?: string | null;
        giteaRepository?: string | null;
        giteaOwner?: string | null;
        giteaBranch?: string | null;
        giteaBuildPath?: string | null;
        bitbucketRepository?: string | null;
        bitbucketRepositorySlug?: string | null;
        bitbucketOwner?: string | null;
        bitbucketBranch?: string | null;
        bitbucketBuildPath?: string | null;
        username?: string | null;
        password?: string | null;
        dockerImage?: string | null;
        registryUrl?: string | null;
        customGitUrl?: string | null;
        customGitBranch?: string | null;
        customGitBuildPath?: string | null;
        customGitSSHKeyId?: string | null;
        enableSubmodules?: boolean;
        dockerfile?: string | null;
        dockerContextPath?: string | null;
        dockerBuildStage?: string | null;
        dropBuildPath?: string | null;
        healthCheckSwarm?: {
            Test?: Array<string>;
            Interval?: number;
            Timeout?: number;
            StartPeriod?: number;
            Retries?: number;
        } | null | null;
        restartPolicySwarm?: {
            Condition?: string;
            Delay?: number;
            MaxAttempts?: number;
            Window?: number;
        } | null | null;
        placementSwarm?: {
            Constraints?: Array<string>;
            Preferences?: Array<{
                Spread: {
                    SpreadDescriptor: string;
                };
            }>;
            MaxReplicas?: number;
            Platforms?: Array<{
                Architecture: string;
                OS: string;
            }>;
        } | null | null;
        updateConfigSwarm?: {
            Parallelism: number;
            Delay?: number;
            FailureAction?: string;
            Monitor?: number;
            MaxFailureRatio?: number;
            Order: string;
        } | null | null;
        rollbackConfigSwarm?: {
            Parallelism: number;
            Delay?: number;
            FailureAction?: string;
            Monitor?: number;
            MaxFailureRatio?: number;
            Order: string;
        } | null | null;
        modeSwarm?: {
            Replicated?: {
                Replicas?: number;
            };
            Global?: {
                [key: string]: unknown;
            };
            ReplicatedJob?: {
                MaxConcurrent?: number;
                TotalCompletions?: number;
            };
            GlobalJob?: {
                [key: string]: unknown;
            };
        } | null | null;
        labelsSwarm?: {
            [key: string]: string;
        } | null | null;
        networkSwarm?: Array<{
            Target?: string;
            Aliases?: Array<string>;
            DriverOpts?: {
                [key: string]: string;
            };
        }> | null | null;
        stopGracePeriodSwarm?: number | null | null;
        endpointSpecSwarm?: {
            Mode?: string;
            Ports?: Array<{
                Protocol?: string;
                TargetPort?: number;
                PublishedPort?: number;
                PublishMode?: string;
            }>;
        } | null | null;
        ulimitsSwarm?: Array<{
            Name: string;
            Soft: number;
            Hard: number;
        }> | null | null;
        replicas?: number;
        applicationStatus?: "idle" | "running" | "done" | "error";
        buildType?: "dockerfile" | "heroku_buildpacks" | "paketo_buildpacks" | "nixpacks" | "static" | "railpack";
        railpackVersion?: string | null;
        herokuVersion?: string | null;
        publishDirectory?: string | null;
        isStaticSpa?: boolean | null;
        createEnvFile?: boolean;
        createdAt?: string;
        registryId?: string | null;
        rollbackRegistryId?: string | null;
        environmentId?: string;
        githubId?: string | null;
        gitlabId?: string | null;
        giteaId?: string | null;
        bitbucketId?: string | null;
        buildServerId?: string | null;
        buildRegistryId?: string | null;
        networkIds?: Array<string> | null;
        detachDokployNetwork?: boolean;
    };
    path?: never;
    query?: never;
    url: "/application.update";
};
export type ApplicationUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationUpdateError = ApplicationUpdateErrors[keyof ApplicationUpdateErrors];
export type ApplicationUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationUpdateResponse = ApplicationUpdateResponses[keyof ApplicationUpdateResponses];
export type ApplicationRefreshTokenData = {
    body: {
        applicationId: string;
    };
    path?: never;
    query?: never;
    url: "/application.refreshToken";
};
export type ApplicationRefreshTokenErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationRefreshTokenError = ApplicationRefreshTokenErrors[keyof ApplicationRefreshTokenErrors];
export type ApplicationRefreshTokenResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationRefreshTokenResponse = ApplicationRefreshTokenResponses[keyof ApplicationRefreshTokenResponses];
export type ApplicationDeployData = {
    body: {
        applicationId: string;
        title?: string;
        description?: string;
    };
    path?: never;
    query?: never;
    url: "/application.deploy";
};
export type ApplicationDeployErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationDeployError = ApplicationDeployErrors[keyof ApplicationDeployErrors];
export type ApplicationDeployResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationDeployResponse = ApplicationDeployResponses[keyof ApplicationDeployResponses];
export type ApplicationCleanQueuesData = {
    body: {
        applicationId: string;
    };
    path?: never;
    query?: never;
    url: "/application.cleanQueues";
};
export type ApplicationCleanQueuesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationCleanQueuesError = ApplicationCleanQueuesErrors[keyof ApplicationCleanQueuesErrors];
export type ApplicationCleanQueuesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationCleanQueuesResponse = ApplicationCleanQueuesResponses[keyof ApplicationCleanQueuesResponses];
export type ApplicationClearDeploymentsData = {
    body: {
        applicationId: string;
    };
    path?: never;
    query?: never;
    url: "/application.clearDeployments";
};
export type ApplicationClearDeploymentsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationClearDeploymentsError = ApplicationClearDeploymentsErrors[keyof ApplicationClearDeploymentsErrors];
export type ApplicationClearDeploymentsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationClearDeploymentsResponse = ApplicationClearDeploymentsResponses[keyof ApplicationClearDeploymentsResponses];
export type ApplicationKillBuildData = {
    body: {
        applicationId: string;
    };
    path?: never;
    query?: never;
    url: "/application.killBuild";
};
export type ApplicationKillBuildErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationKillBuildError = ApplicationKillBuildErrors[keyof ApplicationKillBuildErrors];
export type ApplicationKillBuildResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationKillBuildResponse = ApplicationKillBuildResponses[keyof ApplicationKillBuildResponses];
export type ApplicationReadTraefikConfigData = {
    body?: never;
    path?: never;
    query: {
        applicationId: string;
    };
    url: "/application.readTraefikConfig";
};
export type ApplicationReadTraefikConfigErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationReadTraefikConfigError = ApplicationReadTraefikConfigErrors[keyof ApplicationReadTraefikConfigErrors];
export type ApplicationReadTraefikConfigResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationReadTraefikConfigResponse = ApplicationReadTraefikConfigResponses[keyof ApplicationReadTraefikConfigResponses];
export type ApplicationDropDeploymentData = {
    body: {
        applicationId: string;
        zip: Blob | File;
        dropBuildPath?: string;
    };
    path?: never;
    query?: never;
    url: "/application.dropDeployment";
};
export type ApplicationDropDeploymentErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationDropDeploymentError = ApplicationDropDeploymentErrors[keyof ApplicationDropDeploymentErrors];
export type ApplicationDropDeploymentResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationDropDeploymentResponse = ApplicationDropDeploymentResponses[keyof ApplicationDropDeploymentResponses];
export type ApplicationUpdateTraefikConfigData = {
    body: {
        applicationId: string;
        traefikConfig: string;
    };
    path?: never;
    query?: never;
    url: "/application.updateTraefikConfig";
};
export type ApplicationUpdateTraefikConfigErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationUpdateTraefikConfigError = ApplicationUpdateTraefikConfigErrors[keyof ApplicationUpdateTraefikConfigErrors];
export type ApplicationUpdateTraefikConfigResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationUpdateTraefikConfigResponse = ApplicationUpdateTraefikConfigResponses[keyof ApplicationUpdateTraefikConfigResponses];
export type ApplicationReadAppMonitoringData = {
    body?: never;
    path?: never;
    query: {
        appName: string;
    };
    url: "/application.readAppMonitoring";
};
export type ApplicationReadAppMonitoringErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationReadAppMonitoringError = ApplicationReadAppMonitoringErrors[keyof ApplicationReadAppMonitoringErrors];
export type ApplicationReadAppMonitoringResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationReadAppMonitoringResponse = ApplicationReadAppMonitoringResponses[keyof ApplicationReadAppMonitoringResponses];
export type ApplicationMoveData = {
    body: {
        applicationId: string;
        targetEnvironmentId: string;
    };
    path?: never;
    query?: never;
    url: "/application.move";
};
export type ApplicationMoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationMoveError = ApplicationMoveErrors[keyof ApplicationMoveErrors];
export type ApplicationMoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationMoveResponse = ApplicationMoveResponses[keyof ApplicationMoveResponses];
export type ApplicationCancelDeploymentData = {
    body: {
        applicationId: string;
    };
    path?: never;
    query?: never;
    url: "/application.cancelDeployment";
};
export type ApplicationCancelDeploymentErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationCancelDeploymentError = ApplicationCancelDeploymentErrors[keyof ApplicationCancelDeploymentErrors];
export type ApplicationCancelDeploymentResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationCancelDeploymentResponse = ApplicationCancelDeploymentResponses[keyof ApplicationCancelDeploymentResponses];
export type ApplicationSearchData = {
    body?: never;
    path?: never;
    query?: {
        q?: string;
        name?: string;
        appName?: string;
        description?: string;
        repository?: string;
        owner?: string;
        dockerImage?: string;
        projectId?: string;
        environmentId?: string;
        limit?: number;
        offset?: number;
    };
    url: "/application.search";
};
export type ApplicationSearchErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationSearchError = ApplicationSearchErrors[keyof ApplicationSearchErrors];
export type ApplicationSearchResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationSearchResponse = ApplicationSearchResponses[keyof ApplicationSearchResponses];
export type ApplicationReadLogsData = {
    body?: never;
    path?: never;
    query: {
        applicationId: string;
        tail?: number;
        since?: string;
        search?: string;
    };
    url: "/application.readLogs";
};
export type ApplicationReadLogsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ApplicationReadLogsError = ApplicationReadLogsErrors[keyof ApplicationReadLogsErrors];
export type ApplicationReadLogsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ApplicationReadLogsResponse = ApplicationReadLogsResponses[keyof ApplicationReadLogsResponses];
export type BackupCreateData = {
    body: {
        schedule: string;
        enabled?: boolean | null;
        prefix: string;
        destinationId: string;
        keepLatestCount?: number | null;
        database: string;
        mariadbId?: string | null;
        mysqlId?: string | null;
        postgresId?: string | null;
        mongoId?: string | null;
        libsqlId?: string | null;
        databaseType: "postgres" | "mariadb" | "mysql" | "mongo" | "web-server" | "libsql";
        userId?: string | null;
        backupType?: "database" | "compose";
        composeId?: string | null;
        serviceName?: string | null;
        includeEncryptionKey?: boolean;
        metadata?: unknown | null;
    };
    path?: never;
    query?: never;
    url: "/backup.create";
};
export type BackupCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BackupCreateError = BackupCreateErrors[keyof BackupCreateErrors];
export type BackupCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BackupCreateResponse = BackupCreateResponses[keyof BackupCreateResponses];
export type BackupOneData = {
    body?: never;
    path?: never;
    query: {
        backupId: string;
    };
    url: "/backup.one";
};
export type BackupOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BackupOneError = BackupOneErrors[keyof BackupOneErrors];
export type BackupOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BackupOneResponse = BackupOneResponses[keyof BackupOneResponses];
export type BackupUpdateData = {
    body: {
        schedule: string;
        enabled: boolean | null;
        prefix: string;
        backupId: string;
        destinationId: string;
        database: string;
        keepLatestCount: number | null;
        serviceName: string | null;
        metadata: unknown | null;
        databaseType: "postgres" | "mariadb" | "mysql" | "mongo" | "web-server" | "libsql";
        includeEncryptionKey?: boolean;
    };
    path?: never;
    query?: never;
    url: "/backup.update";
};
export type BackupUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BackupUpdateError = BackupUpdateErrors[keyof BackupUpdateErrors];
export type BackupUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BackupUpdateResponse = BackupUpdateResponses[keyof BackupUpdateResponses];
export type BackupRemoveData = {
    body: {
        backupId: string;
    };
    path?: never;
    query?: never;
    url: "/backup.remove";
};
export type BackupRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BackupRemoveError = BackupRemoveErrors[keyof BackupRemoveErrors];
export type BackupRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BackupRemoveResponse = BackupRemoveResponses[keyof BackupRemoveResponses];
export type BackupManualBackupPostgresData = {
    body: {
        backupId: string;
    };
    path?: never;
    query?: never;
    url: "/backup.manualBackupPostgres";
};
export type BackupManualBackupPostgresErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BackupManualBackupPostgresError = BackupManualBackupPostgresErrors[keyof BackupManualBackupPostgresErrors];
export type BackupManualBackupPostgresResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BackupManualBackupPostgresResponse = BackupManualBackupPostgresResponses[keyof BackupManualBackupPostgresResponses];
export type BackupManualBackupMySqlData = {
    body: {
        backupId: string;
    };
    path?: never;
    query?: never;
    url: "/backup.manualBackupMySql";
};
export type BackupManualBackupMySqlErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BackupManualBackupMySqlError = BackupManualBackupMySqlErrors[keyof BackupManualBackupMySqlErrors];
export type BackupManualBackupMySqlResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BackupManualBackupMySqlResponse = BackupManualBackupMySqlResponses[keyof BackupManualBackupMySqlResponses];
export type BackupManualBackupMariadbData = {
    body: {
        backupId: string;
    };
    path?: never;
    query?: never;
    url: "/backup.manualBackupMariadb";
};
export type BackupManualBackupMariadbErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BackupManualBackupMariadbError = BackupManualBackupMariadbErrors[keyof BackupManualBackupMariadbErrors];
export type BackupManualBackupMariadbResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BackupManualBackupMariadbResponse = BackupManualBackupMariadbResponses[keyof BackupManualBackupMariadbResponses];
export type BackupManualBackupComposeData = {
    body: {
        backupId: string;
    };
    path?: never;
    query?: never;
    url: "/backup.manualBackupCompose";
};
export type BackupManualBackupComposeErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BackupManualBackupComposeError = BackupManualBackupComposeErrors[keyof BackupManualBackupComposeErrors];
export type BackupManualBackupComposeResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BackupManualBackupComposeResponse = BackupManualBackupComposeResponses[keyof BackupManualBackupComposeResponses];
export type BackupManualBackupMongoData = {
    body: {
        backupId: string;
    };
    path?: never;
    query?: never;
    url: "/backup.manualBackupMongo";
};
export type BackupManualBackupMongoErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BackupManualBackupMongoError = BackupManualBackupMongoErrors[keyof BackupManualBackupMongoErrors];
export type BackupManualBackupMongoResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BackupManualBackupMongoResponse = BackupManualBackupMongoResponses[keyof BackupManualBackupMongoResponses];
export type BackupManualBackupLibsqlData = {
    body: {
        backupId: string;
    };
    path?: never;
    query?: never;
    url: "/backup.manualBackupLibsql";
};
export type BackupManualBackupLibsqlErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BackupManualBackupLibsqlError = BackupManualBackupLibsqlErrors[keyof BackupManualBackupLibsqlErrors];
export type BackupManualBackupLibsqlResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BackupManualBackupLibsqlResponse = BackupManualBackupLibsqlResponses[keyof BackupManualBackupLibsqlResponses];
export type BackupManualBackupWebServerData = {
    body: {
        backupId: string;
    };
    path?: never;
    query?: never;
    url: "/backup.manualBackupWebServer";
};
export type BackupManualBackupWebServerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BackupManualBackupWebServerError = BackupManualBackupWebServerErrors[keyof BackupManualBackupWebServerErrors];
export type BackupManualBackupWebServerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BackupManualBackupWebServerResponse = BackupManualBackupWebServerResponses[keyof BackupManualBackupWebServerResponses];
export type BackupListBackupFilesData = {
    body?: never;
    path?: never;
    query: {
        destinationId: string;
        search: string;
        serverId?: string;
    };
    url: "/backup.listBackupFiles";
};
export type BackupListBackupFilesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BackupListBackupFilesError = BackupListBackupFilesErrors[keyof BackupListBackupFilesErrors];
export type BackupListBackupFilesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BackupListBackupFilesResponse = BackupListBackupFilesResponses[keyof BackupListBackupFilesResponses];
export type BitbucketCreateData = {
    body: {
        bitbucketId?: string;
        bitbucketUsername?: string;
        bitbucketEmail?: string;
        appPassword?: string;
        apiToken?: string;
        bitbucketWorkspaceName?: string;
        gitProviderId?: string;
        authId: string;
        name: string;
    };
    path?: never;
    query?: never;
    url: "/bitbucket.create";
};
export type BitbucketCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BitbucketCreateError = BitbucketCreateErrors[keyof BitbucketCreateErrors];
export type BitbucketCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BitbucketCreateResponse = BitbucketCreateResponses[keyof BitbucketCreateResponses];
export type BitbucketOneData = {
    body?: never;
    path?: never;
    query: {
        bitbucketId: string;
    };
    url: "/bitbucket.one";
};
export type BitbucketOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BitbucketOneError = BitbucketOneErrors[keyof BitbucketOneErrors];
export type BitbucketOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BitbucketOneResponse = BitbucketOneResponses[keyof BitbucketOneResponses];
export type BitbucketBitbucketProvidersData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/bitbucket.bitbucketProviders";
};
export type BitbucketBitbucketProvidersErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BitbucketBitbucketProvidersError = BitbucketBitbucketProvidersErrors[keyof BitbucketBitbucketProvidersErrors];
export type BitbucketBitbucketProvidersResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BitbucketBitbucketProvidersResponse = BitbucketBitbucketProvidersResponses[keyof BitbucketBitbucketProvidersResponses];
export type BitbucketGetBitbucketRepositoriesData = {
    body?: never;
    path?: never;
    query: {
        bitbucketId: string;
    };
    url: "/bitbucket.getBitbucketRepositories";
};
export type BitbucketGetBitbucketRepositoriesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BitbucketGetBitbucketRepositoriesError = BitbucketGetBitbucketRepositoriesErrors[keyof BitbucketGetBitbucketRepositoriesErrors];
export type BitbucketGetBitbucketRepositoriesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BitbucketGetBitbucketRepositoriesResponse = BitbucketGetBitbucketRepositoriesResponses[keyof BitbucketGetBitbucketRepositoriesResponses];
export type BitbucketGetBitbucketBranchesData = {
    body?: never;
    path?: never;
    query: {
        owner: string;
        repo: string;
        bitbucketId?: string;
    };
    url: "/bitbucket.getBitbucketBranches";
};
export type BitbucketGetBitbucketBranchesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BitbucketGetBitbucketBranchesError = BitbucketGetBitbucketBranchesErrors[keyof BitbucketGetBitbucketBranchesErrors];
export type BitbucketGetBitbucketBranchesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BitbucketGetBitbucketBranchesResponse = BitbucketGetBitbucketBranchesResponses[keyof BitbucketGetBitbucketBranchesResponses];
export type BitbucketTestConnectionData = {
    body: {
        bitbucketId: string;
        bitbucketUsername?: string;
        bitbucketEmail?: string;
        workspaceName?: string;
        apiToken?: string;
        appPassword?: string;
    };
    path?: never;
    query?: never;
    url: "/bitbucket.testConnection";
};
export type BitbucketTestConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BitbucketTestConnectionError = BitbucketTestConnectionErrors[keyof BitbucketTestConnectionErrors];
export type BitbucketTestConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BitbucketTestConnectionResponse = BitbucketTestConnectionResponses[keyof BitbucketTestConnectionResponses];
export type BitbucketUpdateData = {
    body: {
        bitbucketId: string;
        bitbucketUsername?: string;
        bitbucketEmail?: string;
        appPassword?: string;
        apiToken?: string;
        bitbucketWorkspaceName?: string;
        gitProviderId: string;
        name: string;
        organizationId?: string;
    };
    path?: never;
    query?: never;
    url: "/bitbucket.update";
};
export type BitbucketUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type BitbucketUpdateError = BitbucketUpdateErrors[keyof BitbucketUpdateErrors];
export type BitbucketUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type BitbucketUpdateResponse = BitbucketUpdateResponses[keyof BitbucketUpdateResponses];
export type NetworkAllData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/network.all";
};
export type NetworkAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NetworkAllError = NetworkAllErrors[keyof NetworkAllErrors];
export type NetworkAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NetworkAllResponse = NetworkAllResponses[keyof NetworkAllResponses];
export type NetworkOneData = {
    body?: never;
    path?: never;
    query: {
        networkId: string;
    };
    url: "/network.one";
};
export type NetworkOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NetworkOneError = NetworkOneErrors[keyof NetworkOneErrors];
export type NetworkOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NetworkOneResponse = NetworkOneResponses[keyof NetworkOneResponses];
export type NetworkCreateData = {
    body: {
        name: string;
        driver?: "bridge" | "overlay";
        internal?: boolean;
        attachable?: boolean;
        enableIPv4?: boolean;
        enableIPv6?: boolean;
        mtu?: number | null | null;
        ipam?: {
            driver?: string;
            config?: Array<{
                subnet?: string;
                gateway?: string;
                ipRange?: string;
            }>;
        } | null;
        serverId?: string | null | null;
    };
    path?: never;
    query?: never;
    url: "/network.create";
};
export type NetworkCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NetworkCreateError = NetworkCreateErrors[keyof NetworkCreateErrors];
export type NetworkCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NetworkCreateResponse = NetworkCreateResponses[keyof NetworkCreateResponses];
export type NetworkNetworksToSyncData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/network.networksToSync";
};
export type NetworkNetworksToSyncErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NetworkNetworksToSyncError = NetworkNetworksToSyncErrors[keyof NetworkNetworksToSyncErrors];
export type NetworkNetworksToSyncResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NetworkNetworksToSyncResponse = NetworkNetworksToSyncResponses[keyof NetworkNetworksToSyncResponses];
export type NetworkImportData = {
    body: {
        serverId?: string;
        names: Array<string>;
    };
    path?: never;
    query?: never;
    url: "/network.import";
};
export type NetworkImportErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NetworkImportError = NetworkImportErrors[keyof NetworkImportErrors];
export type NetworkImportResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NetworkImportResponse = NetworkImportResponses[keyof NetworkImportResponses];
export type NetworkInspectData = {
    body?: never;
    path?: never;
    query: {
        networkId: string;
    };
    url: "/network.inspect";
};
export type NetworkInspectErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NetworkInspectError = NetworkInspectErrors[keyof NetworkInspectErrors];
export type NetworkInspectResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NetworkInspectResponse = NetworkInspectResponses[keyof NetworkInspectResponses];
export type NetworkRecreateData = {
    body: {
        networkId: string;
    };
    path?: never;
    query?: never;
    url: "/network.recreate";
};
export type NetworkRecreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NetworkRecreateError = NetworkRecreateErrors[keyof NetworkRecreateErrors];
export type NetworkRecreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NetworkRecreateResponse = NetworkRecreateResponses[keyof NetworkRecreateResponses];
export type NetworkResyncData = {
    body: {
        networkId: string;
    };
    path?: never;
    query?: never;
    url: "/network.resync";
};
export type NetworkResyncErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NetworkResyncError = NetworkResyncErrors[keyof NetworkResyncErrors];
export type NetworkResyncResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NetworkResyncResponse = NetworkResyncResponses[keyof NetworkResyncResponses];
export type NetworkRemoveData = {
    body: {
        networkId: string;
    };
    path?: never;
    query?: never;
    url: "/network.remove";
};
export type NetworkRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NetworkRemoveError = NetworkRemoveErrors[keyof NetworkRemoveErrors];
export type NetworkRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NetworkRemoveResponse = NetworkRemoveResponses[keyof NetworkRemoveResponses];
export type CertificatesCreateData = {
    body: {
        certificateId?: string;
        name: string;
        certificateData: string;
        privateKey: string;
        certificatePath?: string;
        autoRenew?: boolean | null;
        organizationId: string;
        serverId?: string | null;
    };
    path?: never;
    query?: never;
    url: "/certificates.create";
};
export type CertificatesCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type CertificatesCreateError = CertificatesCreateErrors[keyof CertificatesCreateErrors];
export type CertificatesCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type CertificatesCreateResponse = CertificatesCreateResponses[keyof CertificatesCreateResponses];
export type CertificatesOneData = {
    body?: never;
    path?: never;
    query: {
        certificateId: string;
    };
    url: "/certificates.one";
};
export type CertificatesOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type CertificatesOneError = CertificatesOneErrors[keyof CertificatesOneErrors];
export type CertificatesOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type CertificatesOneResponse = CertificatesOneResponses[keyof CertificatesOneResponses];
export type CertificatesRemoveData = {
    body: {
        certificateId: string;
    };
    path?: never;
    query?: never;
    url: "/certificates.remove";
};
export type CertificatesRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type CertificatesRemoveError = CertificatesRemoveErrors[keyof CertificatesRemoveErrors];
export type CertificatesRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type CertificatesRemoveResponse = CertificatesRemoveResponses[keyof CertificatesRemoveResponses];
export type CertificatesAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/certificates.all";
};
export type CertificatesAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type CertificatesAllError = CertificatesAllErrors[keyof CertificatesAllErrors];
export type CertificatesAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type CertificatesAllResponse = CertificatesAllResponses[keyof CertificatesAllResponses];
export type CertificatesUpdateData = {
    body: {
        certificateId: string;
        name?: string;
        certificateData?: string;
        privateKey?: string;
    };
    path?: never;
    query?: never;
    url: "/certificates.update";
};
export type CertificatesUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type CertificatesUpdateError = CertificatesUpdateErrors[keyof CertificatesUpdateErrors];
export type CertificatesUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type CertificatesUpdateResponse = CertificatesUpdateResponses[keyof CertificatesUpdateResponses];
export type ClusterGetNodesData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/cluster.getNodes";
};
export type ClusterGetNodesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ClusterGetNodesError = ClusterGetNodesErrors[keyof ClusterGetNodesErrors];
export type ClusterGetNodesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ClusterGetNodesResponse = ClusterGetNodesResponses[keyof ClusterGetNodesResponses];
export type ClusterRemoveWorkerData = {
    body: {
        nodeId: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/cluster.removeWorker";
};
export type ClusterRemoveWorkerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ClusterRemoveWorkerError = ClusterRemoveWorkerErrors[keyof ClusterRemoveWorkerErrors];
export type ClusterRemoveWorkerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ClusterRemoveWorkerResponse = ClusterRemoveWorkerResponses[keyof ClusterRemoveWorkerResponses];
export type ClusterAddWorkerData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/cluster.addWorker";
};
export type ClusterAddWorkerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ClusterAddWorkerError = ClusterAddWorkerErrors[keyof ClusterAddWorkerErrors];
export type ClusterAddWorkerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ClusterAddWorkerResponse = ClusterAddWorkerResponses[keyof ClusterAddWorkerResponses];
export type ClusterAddManagerData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/cluster.addManager";
};
export type ClusterAddManagerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ClusterAddManagerError = ClusterAddManagerErrors[keyof ClusterAddManagerErrors];
export type ClusterAddManagerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ClusterAddManagerResponse = ClusterAddManagerResponses[keyof ClusterAddManagerResponses];
export type ComposeCreateData = {
    body: {
        name: string;
        description?: string | null;
        environmentId: string;
        composeType?: "docker-compose" | "stack";
        appName?: string;
        serverId?: string | null;
        composeFile?: string;
        sourceType?: "git" | "github" | "gitlab" | "bitbucket" | "gitea" | "raw";
    };
    path?: never;
    query?: never;
    url: "/compose.create";
};
export type ComposeCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeCreateError = ComposeCreateErrors[keyof ComposeCreateErrors];
export type ComposeCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeCreateResponse = ComposeCreateResponses[keyof ComposeCreateResponses];
export type ComposeOneData = {
    body?: never;
    path?: never;
    query: {
        composeId: string;
    };
    url: "/compose.one";
};
export type ComposeOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeOneError = ComposeOneErrors[keyof ComposeOneErrors];
export type ComposeOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeOneResponse = ComposeOneResponses[keyof ComposeOneResponses];
export type ComposeUpdateData = {
    body: {
        composeId: string;
        name?: string;
        appName?: string;
        description?: string | null;
        env?: string | null;
        composeFile?: string;
        refreshToken?: string | null;
        sourceType?: "git" | "github" | "gitlab" | "bitbucket" | "gitea" | "raw";
        composeType?: "docker-compose" | "stack";
        repository?: string | null;
        owner?: string | null;
        branch?: string | null;
        autoDeploy?: boolean | null;
        gitlabProjectId?: number | null;
        gitlabRepository?: string | null;
        gitlabOwner?: string | null;
        gitlabBranch?: string | null;
        gitlabPathNamespace?: string | null;
        bitbucketRepository?: string | null;
        bitbucketRepositorySlug?: string | null;
        bitbucketOwner?: string | null;
        bitbucketBranch?: string | null;
        giteaRepository?: string | null;
        giteaOwner?: string | null;
        giteaBranch?: string | null;
        customGitUrl?: string | null;
        customGitBranch?: string | null;
        customGitSSHKeyId?: string | null;
        command?: string;
        createEnvFile?: boolean;
        enableSubmodules?: boolean;
        composePath?: string;
        suffix?: string;
        randomize?: boolean;
        isolatedDeployment?: boolean;
        isolatedDeploymentsVolume?: boolean;
        triggerType?: "push" | "tag" | null;
        composeStatus?: "idle" | "running" | "done" | "error";
        icon?: string | null | null;
        environmentId?: string;
        createdAt?: string;
        watchPaths?: Array<string> | null;
        githubId?: string | null;
        gitlabId?: string | null;
        bitbucketId?: string | null;
        giteaId?: string | null;
        serviceNetworks?: Array<{
            serviceName: string;
            networkIds: Array<string>;
            detachDokployNetwork: boolean;
        }> | null;
    };
    path?: never;
    query?: never;
    url: "/compose.update";
};
export type ComposeUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeUpdateError = ComposeUpdateErrors[keyof ComposeUpdateErrors];
export type ComposeUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeUpdateResponse = ComposeUpdateResponses[keyof ComposeUpdateResponses];
export type ComposeSaveEnvironmentData = {
    body: {
        composeId: string;
        env: string | null;
        createEnvFile?: boolean;
    };
    path?: never;
    query?: never;
    url: "/compose.saveEnvironment";
};
export type ComposeSaveEnvironmentErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeSaveEnvironmentError = ComposeSaveEnvironmentErrors[keyof ComposeSaveEnvironmentErrors];
export type ComposeSaveEnvironmentResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeSaveEnvironmentResponse = ComposeSaveEnvironmentResponses[keyof ComposeSaveEnvironmentResponses];
export type ComposeDeleteData = {
    body: {
        composeId: string;
        deleteVolumes: boolean;
    };
    path?: never;
    query?: never;
    url: "/compose.delete";
};
export type ComposeDeleteErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeDeleteError = ComposeDeleteErrors[keyof ComposeDeleteErrors];
export type ComposeDeleteResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeDeleteResponse = ComposeDeleteResponses[keyof ComposeDeleteResponses];
export type ComposeCleanQueuesData = {
    body: {
        composeId: string;
    };
    path?: never;
    query?: never;
    url: "/compose.cleanQueues";
};
export type ComposeCleanQueuesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeCleanQueuesError = ComposeCleanQueuesErrors[keyof ComposeCleanQueuesErrors];
export type ComposeCleanQueuesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeCleanQueuesResponse = ComposeCleanQueuesResponses[keyof ComposeCleanQueuesResponses];
export type ComposeClearDeploymentsData = {
    body: {
        composeId: string;
    };
    path?: never;
    query?: never;
    url: "/compose.clearDeployments";
};
export type ComposeClearDeploymentsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeClearDeploymentsError = ComposeClearDeploymentsErrors[keyof ComposeClearDeploymentsErrors];
export type ComposeClearDeploymentsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeClearDeploymentsResponse = ComposeClearDeploymentsResponses[keyof ComposeClearDeploymentsResponses];
export type ComposeKillBuildData = {
    body: {
        composeId: string;
    };
    path?: never;
    query?: never;
    url: "/compose.killBuild";
};
export type ComposeKillBuildErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeKillBuildError = ComposeKillBuildErrors[keyof ComposeKillBuildErrors];
export type ComposeKillBuildResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeKillBuildResponse = ComposeKillBuildResponses[keyof ComposeKillBuildResponses];
export type ComposeLoadServicesData = {
    body?: never;
    path?: never;
    query: {
        composeId: string;
        type?: "fetch" | "cache";
    };
    url: "/compose.loadServices";
};
export type ComposeLoadServicesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeLoadServicesError = ComposeLoadServicesErrors[keyof ComposeLoadServicesErrors];
export type ComposeLoadServicesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeLoadServicesResponse = ComposeLoadServicesResponses[keyof ComposeLoadServicesResponses];
export type ComposeLoadMountsByServiceData = {
    body?: never;
    path?: never;
    query: {
        composeId: string;
        serviceName: string;
    };
    url: "/compose.loadMountsByService";
};
export type ComposeLoadMountsByServiceErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeLoadMountsByServiceError = ComposeLoadMountsByServiceErrors[keyof ComposeLoadMountsByServiceErrors];
export type ComposeLoadMountsByServiceResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeLoadMountsByServiceResponse = ComposeLoadMountsByServiceResponses[keyof ComposeLoadMountsByServiceResponses];
export type ComposeFetchSourceTypeData = {
    body: {
        composeId: string;
    };
    path?: never;
    query?: never;
    url: "/compose.fetchSourceType";
};
export type ComposeFetchSourceTypeErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeFetchSourceTypeError = ComposeFetchSourceTypeErrors[keyof ComposeFetchSourceTypeErrors];
export type ComposeFetchSourceTypeResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeFetchSourceTypeResponse = ComposeFetchSourceTypeResponses[keyof ComposeFetchSourceTypeResponses];
export type ComposeRandomizeComposeData = {
    body: {
        composeId: string;
        suffix?: string;
    };
    path?: never;
    query?: never;
    url: "/compose.randomizeCompose";
};
export type ComposeRandomizeComposeErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeRandomizeComposeError = ComposeRandomizeComposeErrors[keyof ComposeRandomizeComposeErrors];
export type ComposeRandomizeComposeResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeRandomizeComposeResponse = ComposeRandomizeComposeResponses[keyof ComposeRandomizeComposeResponses];
export type ComposeIsolatedDeploymentData = {
    body: {
        composeId: string;
        suffix?: string;
    };
    path?: never;
    query?: never;
    url: "/compose.isolatedDeployment";
};
export type ComposeIsolatedDeploymentErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeIsolatedDeploymentError = ComposeIsolatedDeploymentErrors[keyof ComposeIsolatedDeploymentErrors];
export type ComposeIsolatedDeploymentResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeIsolatedDeploymentResponse = ComposeIsolatedDeploymentResponses[keyof ComposeIsolatedDeploymentResponses];
export type ComposeGetConvertedComposeData = {
    body?: never;
    path?: never;
    query: {
        composeId: string;
    };
    url: "/compose.getConvertedCompose";
};
export type ComposeGetConvertedComposeErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeGetConvertedComposeError = ComposeGetConvertedComposeErrors[keyof ComposeGetConvertedComposeErrors];
export type ComposeGetConvertedComposeResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeGetConvertedComposeResponse = ComposeGetConvertedComposeResponses[keyof ComposeGetConvertedComposeResponses];
export type ComposeDeployData = {
    body: {
        composeId: string;
        title?: string;
        description?: string;
        freshVolumes?: boolean;
    };
    path?: never;
    query?: never;
    url: "/compose.deploy";
};
export type ComposeDeployErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeDeployError = ComposeDeployErrors[keyof ComposeDeployErrors];
export type ComposeDeployResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeDeployResponse = ComposeDeployResponses[keyof ComposeDeployResponses];
export type ComposeRedeployData = {
    body: {
        composeId: string;
        title?: string;
        description?: string;
        freshVolumes?: boolean;
    };
    path?: never;
    query?: never;
    url: "/compose.redeploy";
};
export type ComposeRedeployErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeRedeployError = ComposeRedeployErrors[keyof ComposeRedeployErrors];
export type ComposeRedeployResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeRedeployResponse = ComposeRedeployResponses[keyof ComposeRedeployResponses];
export type ComposeStopData = {
    body: {
        composeId: string;
    };
    path?: never;
    query?: never;
    url: "/compose.stop";
};
export type ComposeStopErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeStopError = ComposeStopErrors[keyof ComposeStopErrors];
export type ComposeStopResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeStopResponse = ComposeStopResponses[keyof ComposeStopResponses];
export type ComposeStartData = {
    body: {
        composeId: string;
    };
    path?: never;
    query?: never;
    url: "/compose.start";
};
export type ComposeStartErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeStartError = ComposeStartErrors[keyof ComposeStartErrors];
export type ComposeStartResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeStartResponse = ComposeStartResponses[keyof ComposeStartResponses];
export type ComposeGetDefaultCommandData = {
    body?: never;
    path?: never;
    query: {
        composeId: string;
    };
    url: "/compose.getDefaultCommand";
};
export type ComposeGetDefaultCommandErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeGetDefaultCommandError = ComposeGetDefaultCommandErrors[keyof ComposeGetDefaultCommandErrors];
export type ComposeGetDefaultCommandResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeGetDefaultCommandResponse = ComposeGetDefaultCommandResponses[keyof ComposeGetDefaultCommandResponses];
export type ComposeRefreshTokenData = {
    body: {
        composeId: string;
    };
    path?: never;
    query?: never;
    url: "/compose.refreshToken";
};
export type ComposeRefreshTokenErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeRefreshTokenError = ComposeRefreshTokenErrors[keyof ComposeRefreshTokenErrors];
export type ComposeRefreshTokenResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeRefreshTokenResponse = ComposeRefreshTokenResponses[keyof ComposeRefreshTokenResponses];
export type ComposeDeployTemplateData = {
    body: {
        environmentId: string;
        serverId?: string;
        id: string;
        baseUrl?: string;
    };
    path?: never;
    query?: never;
    url: "/compose.deployTemplate";
};
export type ComposeDeployTemplateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeDeployTemplateError = ComposeDeployTemplateErrors[keyof ComposeDeployTemplateErrors];
export type ComposeDeployTemplateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeDeployTemplateResponse = ComposeDeployTemplateResponses[keyof ComposeDeployTemplateResponses];
export type ComposeTemplatesData = {
    body?: never;
    path?: never;
    query?: {
        baseUrl?: string;
    };
    url: "/compose.templates";
};
export type ComposeTemplatesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeTemplatesError = ComposeTemplatesErrors[keyof ComposeTemplatesErrors];
export type ComposeTemplatesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeTemplatesResponse = ComposeTemplatesResponses[keyof ComposeTemplatesResponses];
export type ComposeGetTagsData = {
    body?: never;
    path?: never;
    query?: {
        baseUrl?: string;
    };
    url: "/compose.getTags";
};
export type ComposeGetTagsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeGetTagsError = ComposeGetTagsErrors[keyof ComposeGetTagsErrors];
export type ComposeGetTagsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeGetTagsResponse = ComposeGetTagsResponses[keyof ComposeGetTagsResponses];
export type ComposeDisconnectGitProviderData = {
    body: {
        composeId: string;
    };
    path?: never;
    query?: never;
    url: "/compose.disconnectGitProvider";
};
export type ComposeDisconnectGitProviderErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeDisconnectGitProviderError = ComposeDisconnectGitProviderErrors[keyof ComposeDisconnectGitProviderErrors];
export type ComposeDisconnectGitProviderResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeDisconnectGitProviderResponse = ComposeDisconnectGitProviderResponses[keyof ComposeDisconnectGitProviderResponses];
export type ComposeMoveData = {
    body: {
        composeId: string;
        targetEnvironmentId: string;
    };
    path?: never;
    query?: never;
    url: "/compose.move";
};
export type ComposeMoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeMoveError = ComposeMoveErrors[keyof ComposeMoveErrors];
export type ComposeMoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeMoveResponse = ComposeMoveResponses[keyof ComposeMoveResponses];
export type ComposeProcessTemplateData = {
    body: {
        base64: string;
        composeId: string;
    };
    path?: never;
    query?: never;
    url: "/compose.processTemplate";
};
export type ComposeProcessTemplateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeProcessTemplateError = ComposeProcessTemplateErrors[keyof ComposeProcessTemplateErrors];
export type ComposeProcessTemplateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeProcessTemplateResponse = ComposeProcessTemplateResponses[keyof ComposeProcessTemplateResponses];
export type ComposePreviewTemplateData = {
    body: {
        base64: string;
        appName: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/compose.previewTemplate";
};
export type ComposePreviewTemplateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposePreviewTemplateError = ComposePreviewTemplateErrors[keyof ComposePreviewTemplateErrors];
export type ComposePreviewTemplateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposePreviewTemplateResponse = ComposePreviewTemplateResponses[keyof ComposePreviewTemplateResponses];
export type ComposeImportData = {
    body: {
        base64: string;
        composeId: string;
    };
    path?: never;
    query?: never;
    url: "/compose.import";
};
export type ComposeImportErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeImportError = ComposeImportErrors[keyof ComposeImportErrors];
export type ComposeImportResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeImportResponse = ComposeImportResponses[keyof ComposeImportResponses];
export type ComposeCancelDeploymentData = {
    body: {
        composeId: string;
    };
    path?: never;
    query?: never;
    url: "/compose.cancelDeployment";
};
export type ComposeCancelDeploymentErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeCancelDeploymentError = ComposeCancelDeploymentErrors[keyof ComposeCancelDeploymentErrors];
export type ComposeCancelDeploymentResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeCancelDeploymentResponse = ComposeCancelDeploymentResponses[keyof ComposeCancelDeploymentResponses];
export type ComposeSearchData = {
    body?: never;
    path?: never;
    query?: {
        q?: string;
        name?: string;
        appName?: string;
        description?: string;
        projectId?: string;
        environmentId?: string;
        limit?: number;
        offset?: number;
    };
    url: "/compose.search";
};
export type ComposeSearchErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeSearchError = ComposeSearchErrors[keyof ComposeSearchErrors];
export type ComposeSearchResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeSearchResponse = ComposeSearchResponses[keyof ComposeSearchResponses];
export type ComposeReadLogsData = {
    body?: never;
    path?: never;
    query: {
        composeId: string;
        containerId: string;
        tail?: number;
        since?: string;
        search?: string;
    };
    url: "/compose.readLogs";
};
export type ComposeReadLogsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ComposeReadLogsError = ComposeReadLogsErrors[keyof ComposeReadLogsErrors];
export type ComposeReadLogsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ComposeReadLogsResponse = ComposeReadLogsResponses[keyof ComposeReadLogsResponses];
export type DeploymentAllData = {
    body?: never;
    path?: never;
    query: {
        applicationId: string;
    };
    url: "/deployment.all";
};
export type DeploymentAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DeploymentAllError = DeploymentAllErrors[keyof DeploymentAllErrors];
export type DeploymentAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DeploymentAllResponse = DeploymentAllResponses[keyof DeploymentAllResponses];
export type DeploymentAllByComposeData = {
    body?: never;
    path?: never;
    query: {
        composeId: string;
    };
    url: "/deployment.allByCompose";
};
export type DeploymentAllByComposeErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DeploymentAllByComposeError = DeploymentAllByComposeErrors[keyof DeploymentAllByComposeErrors];
export type DeploymentAllByComposeResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DeploymentAllByComposeResponse = DeploymentAllByComposeResponses[keyof DeploymentAllByComposeResponses];
export type DeploymentAllByServerData = {
    body?: never;
    path?: never;
    query: {
        serverId: string;
    };
    url: "/deployment.allByServer";
};
export type DeploymentAllByServerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DeploymentAllByServerError = DeploymentAllByServerErrors[keyof DeploymentAllByServerErrors];
export type DeploymentAllByServerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DeploymentAllByServerResponse = DeploymentAllByServerResponses[keyof DeploymentAllByServerResponses];
export type DeploymentAllCentralizedData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/deployment.allCentralized";
};
export type DeploymentAllCentralizedErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DeploymentAllCentralizedError = DeploymentAllCentralizedErrors[keyof DeploymentAllCentralizedErrors];
export type DeploymentAllCentralizedResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DeploymentAllCentralizedResponse = DeploymentAllCentralizedResponses[keyof DeploymentAllCentralizedResponses];
export type DeploymentQueueListData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/deployment.queueList";
};
export type DeploymentQueueListErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DeploymentQueueListError = DeploymentQueueListErrors[keyof DeploymentQueueListErrors];
export type DeploymentQueueListResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DeploymentQueueListResponse = DeploymentQueueListResponses[keyof DeploymentQueueListResponses];
export type DeploymentAllByTypeData = {
    body?: never;
    path?: never;
    query: {
        id: string;
        type: "application" | "compose" | "server" | "schedule" | "previewDeployment" | "backup" | "volumeBackup";
    };
    url: "/deployment.allByType";
};
export type DeploymentAllByTypeErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DeploymentAllByTypeError = DeploymentAllByTypeErrors[keyof DeploymentAllByTypeErrors];
export type DeploymentAllByTypeResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DeploymentAllByTypeResponse = DeploymentAllByTypeResponses[keyof DeploymentAllByTypeResponses];
export type DeploymentKillProcessData = {
    body: {
        deploymentId: string;
    };
    path?: never;
    query?: never;
    url: "/deployment.killProcess";
};
export type DeploymentKillProcessErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DeploymentKillProcessError = DeploymentKillProcessErrors[keyof DeploymentKillProcessErrors];
export type DeploymentKillProcessResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DeploymentKillProcessResponse = DeploymentKillProcessResponses[keyof DeploymentKillProcessResponses];
export type DeploymentRemoveDeploymentData = {
    body: {
        deploymentId: string;
    };
    path?: never;
    query?: never;
    url: "/deployment.removeDeployment";
};
export type DeploymentRemoveDeploymentErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DeploymentRemoveDeploymentError = DeploymentRemoveDeploymentErrors[keyof DeploymentRemoveDeploymentErrors];
export type DeploymentRemoveDeploymentResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DeploymentRemoveDeploymentResponse = DeploymentRemoveDeploymentResponses[keyof DeploymentRemoveDeploymentResponses];
export type DeploymentReadLogsData = {
    body?: never;
    path?: never;
    query: {
        deploymentId: string;
        tail?: number;
    };
    url: "/deployment.readLogs";
};
export type DeploymentReadLogsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DeploymentReadLogsError = DeploymentReadLogsErrors[keyof DeploymentReadLogsErrors];
export type DeploymentReadLogsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DeploymentReadLogsResponse = DeploymentReadLogsResponses[keyof DeploymentReadLogsResponses];
export type DestinationCreateData = {
    body: {
        name: string;
        provider: string | null;
        accessKey: string;
        bucket: string;
        region: string;
        endpoint: string;
        secretAccessKey: string;
        additionalFlags: Array<string> | null;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/destination.create";
};
export type DestinationCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DestinationCreateError = DestinationCreateErrors[keyof DestinationCreateErrors];
export type DestinationCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DestinationCreateResponse = DestinationCreateResponses[keyof DestinationCreateResponses];
export type DestinationTestConnectionData = {
    body: {
        name: string;
        provider: string | null;
        accessKey: string;
        bucket: string;
        region: string;
        endpoint: string;
        secretAccessKey: string;
        additionalFlags: Array<string> | null;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/destination.testConnection";
};
export type DestinationTestConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DestinationTestConnectionError = DestinationTestConnectionErrors[keyof DestinationTestConnectionErrors];
export type DestinationTestConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DestinationTestConnectionResponse = DestinationTestConnectionResponses[keyof DestinationTestConnectionResponses];
export type DestinationOneData = {
    body?: never;
    path?: never;
    query: {
        destinationId: string;
    };
    url: "/destination.one";
};
export type DestinationOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DestinationOneError = DestinationOneErrors[keyof DestinationOneErrors];
export type DestinationOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DestinationOneResponse = DestinationOneResponses[keyof DestinationOneResponses];
export type DestinationAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/destination.all";
};
export type DestinationAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DestinationAllError = DestinationAllErrors[keyof DestinationAllErrors];
export type DestinationAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DestinationAllResponse = DestinationAllResponses[keyof DestinationAllResponses];
export type DestinationRemoveData = {
    body: {
        destinationId: string;
    };
    path?: never;
    query?: never;
    url: "/destination.remove";
};
export type DestinationRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DestinationRemoveError = DestinationRemoveErrors[keyof DestinationRemoveErrors];
export type DestinationRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DestinationRemoveResponse = DestinationRemoveResponses[keyof DestinationRemoveResponses];
export type DestinationUpdateData = {
    body: {
        name: string;
        accessKey: string;
        bucket: string;
        region: string;
        endpoint: string;
        secretAccessKey: string;
        destinationId: string;
        provider: string | null;
        additionalFlags: Array<string> | null;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/destination.update";
};
export type DestinationUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DestinationUpdateError = DestinationUpdateErrors[keyof DestinationUpdateErrors];
export type DestinationUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DestinationUpdateResponse = DestinationUpdateResponses[keyof DestinationUpdateResponses];
export type DnsProviderCreateData = {
    body: {
        name: string;
        config: {
            providerType: "cloudflare";
            apiToken: string;
        } | {
            providerType: "route53";
            accessKeyId: string;
            secretAccessKey: string;
        } | {
            providerType: "porkbun";
            apiKey: string;
            secretApiKey: string;
        } | {
            providerType: "infomaniak";
            apiToken: string;
        } | {
            providerType: "ovh";
            endpoint?: "ovh-eu" | "ovh-ca" | "ovh-us" | "kimsufi-eu" | "kimsufi-ca" | "soyoustart-eu" | "soyoustart-ca";
            applicationKey: string;
            applicationSecret: string;
            consumerKey: string;
        };
    };
    path?: never;
    query?: never;
    url: "/dnsProvider.create";
};
export type DnsProviderCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DnsProviderCreateError = DnsProviderCreateErrors[keyof DnsProviderCreateErrors];
export type DnsProviderCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DnsProviderCreateResponse = DnsProviderCreateResponses[keyof DnsProviderCreateResponses];
export type DnsProviderUpdateData = {
    body: {
        dnsProviderId: string;
        name: string;
        config: {
            providerType: "cloudflare";
            apiToken: string;
        } | {
            providerType: "route53";
            accessKeyId: string;
            secretAccessKey: string;
        } | {
            providerType: "porkbun";
            apiKey: string;
            secretApiKey: string;
        } | {
            providerType: "infomaniak";
            apiToken: string;
        } | {
            providerType: "ovh";
            endpoint?: "ovh-eu" | "ovh-ca" | "ovh-us" | "kimsufi-eu" | "kimsufi-ca" | "soyoustart-eu" | "soyoustart-ca";
            applicationKey: string;
            applicationSecret: string;
            consumerKey: string;
        };
    };
    path?: never;
    query?: never;
    url: "/dnsProvider.update";
};
export type DnsProviderUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DnsProviderUpdateError = DnsProviderUpdateErrors[keyof DnsProviderUpdateErrors];
export type DnsProviderUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DnsProviderUpdateResponse = DnsProviderUpdateResponses[keyof DnsProviderUpdateResponses];
export type DnsProviderRemoveData = {
    body: {
        dnsProviderId: string;
    };
    path?: never;
    query?: never;
    url: "/dnsProvider.remove";
};
export type DnsProviderRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DnsProviderRemoveError = DnsProviderRemoveErrors[keyof DnsProviderRemoveErrors];
export type DnsProviderRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DnsProviderRemoveResponse = DnsProviderRemoveResponses[keyof DnsProviderRemoveResponses];
export type DnsProviderAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/dnsProvider.all";
};
export type DnsProviderAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DnsProviderAllError = DnsProviderAllErrors[keyof DnsProviderAllErrors];
export type DnsProviderAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DnsProviderAllResponse = DnsProviderAllResponses[keyof DnsProviderAllResponses];
export type DnsProviderOneData = {
    body?: never;
    path?: never;
    query: {
        dnsProviderId: string;
    };
    url: "/dnsProvider.one";
};
export type DnsProviderOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DnsProviderOneError = DnsProviderOneErrors[keyof DnsProviderOneErrors];
export type DnsProviderOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DnsProviderOneResponse = DnsProviderOneResponses[keyof DnsProviderOneResponses];
export type DnsProviderTestConnectionData = {
    body: {
        dnsProviderId?: string;
        config?: {
            providerType: "cloudflare";
            apiToken: string;
        } | {
            providerType: "route53";
            accessKeyId: string;
            secretAccessKey: string;
        } | {
            providerType: "porkbun";
            apiKey: string;
            secretApiKey: string;
        } | {
            providerType: "infomaniak";
            apiToken: string;
        } | {
            providerType: "ovh";
            endpoint?: "ovh-eu" | "ovh-ca" | "ovh-us" | "kimsufi-eu" | "kimsufi-ca" | "soyoustart-eu" | "soyoustart-ca";
            applicationKey: string;
            applicationSecret: string;
            consumerKey: string;
        };
    };
    path?: never;
    query?: never;
    url: "/dnsProvider.testConnection";
};
export type DnsProviderTestConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DnsProviderTestConnectionError = DnsProviderTestConnectionErrors[keyof DnsProviderTestConnectionErrors];
export type DnsProviderTestConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DnsProviderTestConnectionResponse = DnsProviderTestConnectionResponses[keyof DnsProviderTestConnectionResponses];
export type DnsProviderListZonesData = {
    body?: never;
    path?: never;
    query: {
        dnsProviderId: string;
    };
    url: "/dnsProvider.listZones";
};
export type DnsProviderListZonesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DnsProviderListZonesError = DnsProviderListZonesErrors[keyof DnsProviderListZonesErrors];
export type DnsProviderListZonesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DnsProviderListZonesResponse = DnsProviderListZonesResponses[keyof DnsProviderListZonesResponses];
export type DnsProviderListRecordsData = {
    body?: never;
    path?: never;
    query: {
        dnsProviderId: string;
        zoneId: string;
    };
    url: "/dnsProvider.listRecords";
};
export type DnsProviderListRecordsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DnsProviderListRecordsError = DnsProviderListRecordsErrors[keyof DnsProviderListRecordsErrors];
export type DnsProviderListRecordsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DnsProviderListRecordsResponse = DnsProviderListRecordsResponses[keyof DnsProviderListRecordsResponses];
export type DnsProviderCreateRecordData = {
    body: {
        type: "A" | "AAAA" | "CNAME" | "MX" | "TXT" | "NS" | "SRV" | "CAA" | "PTR";
        name: string;
        content: string;
        ttl?: number;
        proxied?: boolean;
        dnsProviderId: string;
        zoneId: string;
    };
    path?: never;
    query?: never;
    url: "/dnsProvider.createRecord";
};
export type DnsProviderCreateRecordErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DnsProviderCreateRecordError = DnsProviderCreateRecordErrors[keyof DnsProviderCreateRecordErrors];
export type DnsProviderCreateRecordResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DnsProviderCreateRecordResponse = DnsProviderCreateRecordResponses[keyof DnsProviderCreateRecordResponses];
export type DnsProviderUpdateRecordData = {
    body: {
        type: "A" | "AAAA" | "CNAME" | "MX" | "TXT" | "NS" | "SRV" | "CAA" | "PTR";
        name: string;
        content: string;
        ttl?: number;
        proxied?: boolean;
        dnsProviderId: string;
        zoneId: string;
        recordId: string;
    };
    path?: never;
    query?: never;
    url: "/dnsProvider.updateRecord";
};
export type DnsProviderUpdateRecordErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DnsProviderUpdateRecordError = DnsProviderUpdateRecordErrors[keyof DnsProviderUpdateRecordErrors];
export type DnsProviderUpdateRecordResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DnsProviderUpdateRecordResponse = DnsProviderUpdateRecordResponses[keyof DnsProviderUpdateRecordResponses];
export type DnsProviderDeleteRecordData = {
    body: {
        dnsProviderId: string;
        zoneId: string;
        recordId: string;
    };
    path?: never;
    query?: never;
    url: "/dnsProvider.deleteRecord";
};
export type DnsProviderDeleteRecordErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DnsProviderDeleteRecordError = DnsProviderDeleteRecordErrors[keyof DnsProviderDeleteRecordErrors];
export type DnsProviderDeleteRecordResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DnsProviderDeleteRecordResponse = DnsProviderDeleteRecordResponses[keyof DnsProviderDeleteRecordResponses];
export type DockerGetContainersData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/docker.getContainers";
};
export type DockerGetContainersErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerGetContainersError = DockerGetContainersErrors[keyof DockerGetContainersErrors];
export type DockerGetContainersResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerGetContainersResponse = DockerGetContainersResponses[keyof DockerGetContainersResponses];
export type DockerGetServerHealthData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
        sinceHours?: number;
    };
    url: "/docker.getServerHealth";
};
export type DockerGetServerHealthErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerGetServerHealthError = DockerGetServerHealthErrors[keyof DockerGetServerHealthErrors];
export type DockerGetServerHealthResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerGetServerHealthResponse = DockerGetServerHealthResponses[keyof DockerGetServerHealthResponses];
export type DockerRestartContainerData = {
    body: {
        containerId: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/docker.restartContainer";
};
export type DockerRestartContainerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerRestartContainerError = DockerRestartContainerErrors[keyof DockerRestartContainerErrors];
export type DockerRestartContainerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerRestartContainerResponse = DockerRestartContainerResponses[keyof DockerRestartContainerResponses];
export type DockerStartContainerData = {
    body: {
        containerId: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/docker.startContainer";
};
export type DockerStartContainerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerStartContainerError = DockerStartContainerErrors[keyof DockerStartContainerErrors];
export type DockerStartContainerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerStartContainerResponse = DockerStartContainerResponses[keyof DockerStartContainerResponses];
export type DockerStopContainerData = {
    body: {
        containerId: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/docker.stopContainer";
};
export type DockerStopContainerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerStopContainerError = DockerStopContainerErrors[keyof DockerStopContainerErrors];
export type DockerStopContainerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerStopContainerResponse = DockerStopContainerResponses[keyof DockerStopContainerResponses];
export type DockerKillContainerData = {
    body: {
        containerId: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/docker.killContainer";
};
export type DockerKillContainerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerKillContainerError = DockerKillContainerErrors[keyof DockerKillContainerErrors];
export type DockerKillContainerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerKillContainerResponse = DockerKillContainerResponses[keyof DockerKillContainerResponses];
export type DockerRemoveContainerData = {
    body: {
        containerId: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/docker.removeContainer";
};
export type DockerRemoveContainerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerRemoveContainerError = DockerRemoveContainerErrors[keyof DockerRemoveContainerErrors];
export type DockerRemoveContainerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerRemoveContainerResponse = DockerRemoveContainerResponses[keyof DockerRemoveContainerResponses];
export type DockerGetConfigData = {
    body?: never;
    path?: never;
    query: {
        containerId: string;
        serverId?: string;
    };
    url: "/docker.getConfig";
};
export type DockerGetConfigErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerGetConfigError = DockerGetConfigErrors[keyof DockerGetConfigErrors];
export type DockerGetConfigResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerGetConfigResponse = DockerGetConfigResponses[keyof DockerGetConfigResponses];
export type DockerGetContainersByAppNameMatchData = {
    body?: never;
    path?: never;
    query: {
        appType?: "stack" | "docker-compose";
        appName: string;
        serverId?: string;
    };
    url: "/docker.getContainersByAppNameMatch";
};
export type DockerGetContainersByAppNameMatchErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerGetContainersByAppNameMatchError = DockerGetContainersByAppNameMatchErrors[keyof DockerGetContainersByAppNameMatchErrors];
export type DockerGetContainersByAppNameMatchResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerGetContainersByAppNameMatchResponse = DockerGetContainersByAppNameMatchResponses[keyof DockerGetContainersByAppNameMatchResponses];
export type DockerGetContainersByAppLabelData = {
    body?: never;
    path?: never;
    query: {
        appName: string;
        serverId?: string;
        type: "standalone" | "swarm";
    };
    url: "/docker.getContainersByAppLabel";
};
export type DockerGetContainersByAppLabelErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerGetContainersByAppLabelError = DockerGetContainersByAppLabelErrors[keyof DockerGetContainersByAppLabelErrors];
export type DockerGetContainersByAppLabelResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerGetContainersByAppLabelResponse = DockerGetContainersByAppLabelResponses[keyof DockerGetContainersByAppLabelResponses];
export type DockerGetStackContainersByAppNameData = {
    body?: never;
    path?: never;
    query: {
        appName: string;
        serverId?: string;
    };
    url: "/docker.getStackContainersByAppName";
};
export type DockerGetStackContainersByAppNameErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerGetStackContainersByAppNameError = DockerGetStackContainersByAppNameErrors[keyof DockerGetStackContainersByAppNameErrors];
export type DockerGetStackContainersByAppNameResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerGetStackContainersByAppNameResponse = DockerGetStackContainersByAppNameResponses[keyof DockerGetStackContainersByAppNameResponses];
export type DockerGetServiceContainersByAppNameData = {
    body?: never;
    path?: never;
    query: {
        appName: string;
        serverId?: string;
    };
    url: "/docker.getServiceContainersByAppName";
};
export type DockerGetServiceContainersByAppNameErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerGetServiceContainersByAppNameError = DockerGetServiceContainersByAppNameErrors[keyof DockerGetServiceContainersByAppNameErrors];
export type DockerGetServiceContainersByAppNameResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerGetServiceContainersByAppNameResponse = DockerGetServiceContainersByAppNameResponses[keyof DockerGetServiceContainersByAppNameResponses];
export type DockerUploadFileToContainerData = {
    body: {
        containerId: string;
        file: Blob | File;
        destinationPath: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/docker.uploadFileToContainer";
};
export type DockerUploadFileToContainerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerUploadFileToContainerError = DockerUploadFileToContainerErrors[keyof DockerUploadFileToContainerErrors];
export type DockerUploadFileToContainerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerUploadFileToContainerResponse = DockerUploadFileToContainerResponses[keyof DockerUploadFileToContainerResponses];
export type DockerListContainerFilesData = {
    body?: never;
    path?: never;
    query: {
        containerId: string;
        path: string;
        serverId?: string;
    };
    url: "/docker.listContainerFiles";
};
export type DockerListContainerFilesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerListContainerFilesError = DockerListContainerFilesErrors[keyof DockerListContainerFilesErrors];
export type DockerListContainerFilesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerListContainerFilesResponse = DockerListContainerFilesResponses[keyof DockerListContainerFilesResponses];
export type DockerReadContainerFileData = {
    body?: never;
    path?: never;
    query: {
        containerId: string;
        path: string;
        serverId?: string;
    };
    url: "/docker.readContainerFile";
};
export type DockerReadContainerFileErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerReadContainerFileError = DockerReadContainerFileErrors[keyof DockerReadContainerFileErrors];
export type DockerReadContainerFileResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerReadContainerFileResponse = DockerReadContainerFileResponses[keyof DockerReadContainerFileResponses];
export type DockerWriteContainerFileData = {
    body: {
        containerId: string;
        path: string;
        content: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/docker.writeContainerFile";
};
export type DockerWriteContainerFileErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerWriteContainerFileError = DockerWriteContainerFileErrors[keyof DockerWriteContainerFileErrors];
export type DockerWriteContainerFileResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerWriteContainerFileResponse = DockerWriteContainerFileResponses[keyof DockerWriteContainerFileResponses];
export type DockerDeleteContainerFileData = {
    body: {
        containerId: string;
        path: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/docker.deleteContainerFile";
};
export type DockerDeleteContainerFileErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerDeleteContainerFileError = DockerDeleteContainerFileErrors[keyof DockerDeleteContainerFileErrors];
export type DockerDeleteContainerFileResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerDeleteContainerFileResponse = DockerDeleteContainerFileResponses[keyof DockerDeleteContainerFileResponses];
export type DockerGetEventsData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
        minutes?: number;
    };
    url: "/docker.getEvents";
};
export type DockerGetEventsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerGetEventsError = DockerGetEventsErrors[keyof DockerGetEventsErrors];
export type DockerGetEventsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerGetEventsResponse = DockerGetEventsResponses[keyof DockerGetEventsResponses];
export type DockerDiskUsageGetDiskUsageData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/dockerDiskUsage.getDiskUsage";
};
export type DockerDiskUsageGetDiskUsageErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerDiskUsageGetDiskUsageError = DockerDiskUsageGetDiskUsageErrors[keyof DockerDiskUsageGetDiskUsageErrors];
export type DockerDiskUsageGetDiskUsageResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerDiskUsageGetDiskUsageResponse = DockerDiskUsageGetDiskUsageResponses[keyof DockerDiskUsageGetDiskUsageResponses];
export type DockerDiskUsageGetBuildCacheData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/dockerDiskUsage.getBuildCache";
};
export type DockerDiskUsageGetBuildCacheErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerDiskUsageGetBuildCacheError = DockerDiskUsageGetBuildCacheErrors[keyof DockerDiskUsageGetBuildCacheErrors];
export type DockerDiskUsageGetBuildCacheResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerDiskUsageGetBuildCacheResponse = DockerDiskUsageGetBuildCacheResponses[keyof DockerDiskUsageGetBuildCacheResponses];
export type DockerDiskUsagePruneBuildCacheData = {
    body: {
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/dockerDiskUsage.pruneBuildCache";
};
export type DockerDiskUsagePruneBuildCacheErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerDiskUsagePruneBuildCacheError = DockerDiskUsagePruneBuildCacheErrors[keyof DockerDiskUsagePruneBuildCacheErrors];
export type DockerDiskUsagePruneBuildCacheResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerDiskUsagePruneBuildCacheResponse = DockerDiskUsagePruneBuildCacheResponses[keyof DockerDiskUsagePruneBuildCacheResponses];
export type DockerImageGetImagesData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/dockerImage.getImages";
};
export type DockerImageGetImagesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerImageGetImagesError = DockerImageGetImagesErrors[keyof DockerImageGetImagesErrors];
export type DockerImageGetImagesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerImageGetImagesResponse = DockerImageGetImagesResponses[keyof DockerImageGetImagesResponses];
export type DockerImageGetImageConfigData = {
    body?: never;
    path?: never;
    query: {
        imageRef: string;
        serverId?: string;
    };
    url: "/dockerImage.getImageConfig";
};
export type DockerImageGetImageConfigErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerImageGetImageConfigError = DockerImageGetImageConfigErrors[keyof DockerImageGetImageConfigErrors];
export type DockerImageGetImageConfigResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerImageGetImageConfigResponse = DockerImageGetImageConfigResponses[keyof DockerImageGetImageConfigResponses];
export type DockerImageRemoveImageData = {
    body: {
        repository: string;
        tag: string;
        id: string;
        force?: boolean;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/dockerImage.removeImage";
};
export type DockerImageRemoveImageErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerImageRemoveImageError = DockerImageRemoveImageErrors[keyof DockerImageRemoveImageErrors];
export type DockerImageRemoveImageResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerImageRemoveImageResponse = DockerImageRemoveImageResponses[keyof DockerImageRemoveImageResponses];
export type DockerVolumeGetVolumesData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/dockerVolume.getVolumes";
};
export type DockerVolumeGetVolumesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerVolumeGetVolumesError = DockerVolumeGetVolumesErrors[keyof DockerVolumeGetVolumesErrors];
export type DockerVolumeGetVolumesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerVolumeGetVolumesResponse = DockerVolumeGetVolumesResponses[keyof DockerVolumeGetVolumesResponses];
export type DockerVolumeGetVolumesSizeData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/dockerVolume.getVolumesSize";
};
export type DockerVolumeGetVolumesSizeErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerVolumeGetVolumesSizeError = DockerVolumeGetVolumesSizeErrors[keyof DockerVolumeGetVolumesSizeErrors];
export type DockerVolumeGetVolumesSizeResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerVolumeGetVolumesSizeResponse = DockerVolumeGetVolumesSizeResponses[keyof DockerVolumeGetVolumesSizeResponses];
export type DockerVolumeListVolumeFilesData = {
    body?: never;
    path?: never;
    query: {
        volumeName: string;
        path: string;
        serverId?: string;
    };
    url: "/dockerVolume.listVolumeFiles";
};
export type DockerVolumeListVolumeFilesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerVolumeListVolumeFilesError = DockerVolumeListVolumeFilesErrors[keyof DockerVolumeListVolumeFilesErrors];
export type DockerVolumeListVolumeFilesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerVolumeListVolumeFilesResponse = DockerVolumeListVolumeFilesResponses[keyof DockerVolumeListVolumeFilesResponses];
export type DockerVolumeReadVolumeFileData = {
    body?: never;
    path?: never;
    query: {
        volumeName: string;
        path: string;
        serverId?: string;
    };
    url: "/dockerVolume.readVolumeFile";
};
export type DockerVolumeReadVolumeFileErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerVolumeReadVolumeFileError = DockerVolumeReadVolumeFileErrors[keyof DockerVolumeReadVolumeFileErrors];
export type DockerVolumeReadVolumeFileResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerVolumeReadVolumeFileResponse = DockerVolumeReadVolumeFileResponses[keyof DockerVolumeReadVolumeFileResponses];
export type DockerVolumeWriteVolumeFileData = {
    body: {
        volumeName: string;
        path: string;
        content: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/dockerVolume.writeVolumeFile";
};
export type DockerVolumeWriteVolumeFileErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerVolumeWriteVolumeFileError = DockerVolumeWriteVolumeFileErrors[keyof DockerVolumeWriteVolumeFileErrors];
export type DockerVolumeWriteVolumeFileResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerVolumeWriteVolumeFileResponse = DockerVolumeWriteVolumeFileResponses[keyof DockerVolumeWriteVolumeFileResponses];
export type DockerVolumeDeleteVolumeFileData = {
    body: {
        volumeName: string;
        path: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/dockerVolume.deleteVolumeFile";
};
export type DockerVolumeDeleteVolumeFileErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerVolumeDeleteVolumeFileError = DockerVolumeDeleteVolumeFileErrors[keyof DockerVolumeDeleteVolumeFileErrors];
export type DockerVolumeDeleteVolumeFileResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerVolumeDeleteVolumeFileResponse = DockerVolumeDeleteVolumeFileResponses[keyof DockerVolumeDeleteVolumeFileResponses];
export type DockerVolumeGetVolumeConfigData = {
    body?: never;
    path?: never;
    query: {
        volumeName: string;
        serverId?: string;
    };
    url: "/dockerVolume.getVolumeConfig";
};
export type DockerVolumeGetVolumeConfigErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerVolumeGetVolumeConfigError = DockerVolumeGetVolumeConfigErrors[keyof DockerVolumeGetVolumeConfigErrors];
export type DockerVolumeGetVolumeConfigResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerVolumeGetVolumeConfigResponse = DockerVolumeGetVolumeConfigResponses[keyof DockerVolumeGetVolumeConfigResponses];
export type DockerVolumeRemoveVolumeData = {
    body: {
        volumeName: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/dockerVolume.removeVolume";
};
export type DockerVolumeRemoveVolumeErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DockerVolumeRemoveVolumeError = DockerVolumeRemoveVolumeErrors[keyof DockerVolumeRemoveVolumeErrors];
export type DockerVolumeRemoveVolumeResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DockerVolumeRemoveVolumeResponse = DockerVolumeRemoveVolumeResponses[keyof DockerVolumeRemoveVolumeResponses];
export type DomainCreateData = {
    body: {
        host: string;
        path?: string | null;
        port?: number | null;
        customEntrypoint?: string | null;
        https?: boolean;
        applicationId?: string | null;
        certificateType?: "letsencrypt" | "none" | "custom";
        customCertResolver?: string | null;
        composeId?: string | null;
        serviceName?: string | null;
        domainType?: "compose" | "application" | "preview" | null;
        previewDeploymentId?: string | null;
        internalPath?: string | null;
        stripPath?: boolean;
        middlewares?: Array<string> | null;
        forwardAuthEnabled?: boolean;
    };
    path?: never;
    query?: never;
    url: "/domain.create";
};
export type DomainCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DomainCreateError = DomainCreateErrors[keyof DomainCreateErrors];
export type DomainCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DomainCreateResponse = DomainCreateResponses[keyof DomainCreateResponses];
export type DomainByApplicationIdData = {
    body?: never;
    path?: never;
    query: {
        applicationId: string;
    };
    url: "/domain.byApplicationId";
};
export type DomainByApplicationIdErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DomainByApplicationIdError = DomainByApplicationIdErrors[keyof DomainByApplicationIdErrors];
export type DomainByApplicationIdResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DomainByApplicationIdResponse = DomainByApplicationIdResponses[keyof DomainByApplicationIdResponses];
export type DomainByComposeIdData = {
    body?: never;
    path?: never;
    query: {
        composeId: string;
    };
    url: "/domain.byComposeId";
};
export type DomainByComposeIdErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DomainByComposeIdError = DomainByComposeIdErrors[keyof DomainByComposeIdErrors];
export type DomainByComposeIdResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DomainByComposeIdResponse = DomainByComposeIdResponses[keyof DomainByComposeIdResponses];
export type DomainGenerateDomainData = {
    body: {
        appName: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/domain.generateDomain";
};
export type DomainGenerateDomainErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DomainGenerateDomainError = DomainGenerateDomainErrors[keyof DomainGenerateDomainErrors];
export type DomainGenerateDomainResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DomainGenerateDomainResponse = DomainGenerateDomainResponses[keyof DomainGenerateDomainResponses];
export type DomainCanGenerateTraefikMeDomainsData = {
    body?: never;
    path?: never;
    query: {
        serverId: string;
    };
    url: "/domain.canGenerateTraefikMeDomains";
};
export type DomainCanGenerateTraefikMeDomainsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DomainCanGenerateTraefikMeDomainsError = DomainCanGenerateTraefikMeDomainsErrors[keyof DomainCanGenerateTraefikMeDomainsErrors];
export type DomainCanGenerateTraefikMeDomainsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DomainCanGenerateTraefikMeDomainsResponse = DomainCanGenerateTraefikMeDomainsResponses[keyof DomainCanGenerateTraefikMeDomainsResponses];
export type DomainUpdateData = {
    body: {
        host: string;
        path?: string | null;
        port?: number | null;
        customEntrypoint?: string | null;
        https?: boolean;
        certificateType?: "letsencrypt" | "none" | "custom";
        customCertResolver?: string | null;
        serviceName?: string | null;
        domainType?: "compose" | "application" | "preview" | null;
        internalPath?: string | null;
        stripPath?: boolean;
        middlewares?: Array<string> | null;
        forwardAuthEnabled?: boolean;
        enabled?: boolean;
        domainId: string;
    };
    path?: never;
    query?: never;
    url: "/domain.update";
};
export type DomainUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DomainUpdateError = DomainUpdateErrors[keyof DomainUpdateErrors];
export type DomainUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DomainUpdateResponse = DomainUpdateResponses[keyof DomainUpdateResponses];
export type DomainToggleEnableData = {
    body: {
        domainId: string;
    };
    path?: never;
    query?: never;
    url: "/domain.toggleEnable";
};
export type DomainToggleEnableErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DomainToggleEnableError = DomainToggleEnableErrors[keyof DomainToggleEnableErrors];
export type DomainToggleEnableResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DomainToggleEnableResponse = DomainToggleEnableResponses[keyof DomainToggleEnableResponses];
export type DomainOneData = {
    body?: never;
    path?: never;
    query: {
        domainId: string;
    };
    url: "/domain.one";
};
export type DomainOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DomainOneError = DomainOneErrors[keyof DomainOneErrors];
export type DomainOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DomainOneResponse = DomainOneResponses[keyof DomainOneResponses];
export type DomainDeleteData = {
    body: {
        domainId: string;
    };
    path?: never;
    query?: never;
    url: "/domain.delete";
};
export type DomainDeleteErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DomainDeleteError = DomainDeleteErrors[keyof DomainDeleteErrors];
export type DomainDeleteResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DomainDeleteResponse = DomainDeleteResponses[keyof DomainDeleteResponses];
export type DomainValidateDomainData = {
    body: {
        domain: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/domain.validateDomain";
};
export type DomainValidateDomainErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type DomainValidateDomainError = DomainValidateDomainErrors[keyof DomainValidateDomainErrors];
export type DomainValidateDomainResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type DomainValidateDomainResponse = DomainValidateDomainResponses[keyof DomainValidateDomainResponses];
export type GiteaCreateData = {
    body: {
        giteaId?: string;
        giteaUrl: string;
        giteaInternalUrl?: string | null;
        redirectUri?: string;
        clientId?: string;
        clientSecret?: string;
        gitProviderId?: string;
        accessToken?: string;
        refreshToken?: string;
        expiresAt?: number;
        scopes?: string;
        lastAuthenticatedAt?: number;
        name: string;
        giteaUsername?: string;
        organizationName?: string;
    };
    path?: never;
    query?: never;
    url: "/gitea.create";
};
export type GiteaCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GiteaCreateError = GiteaCreateErrors[keyof GiteaCreateErrors];
export type GiteaCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GiteaCreateResponse = GiteaCreateResponses[keyof GiteaCreateResponses];
export type GiteaOneData = {
    body?: never;
    path?: never;
    query: {
        giteaId: string;
    };
    url: "/gitea.one";
};
export type GiteaOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GiteaOneError = GiteaOneErrors[keyof GiteaOneErrors];
export type GiteaOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GiteaOneResponse = GiteaOneResponses[keyof GiteaOneResponses];
export type GiteaGiteaProvidersData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/gitea.giteaProviders";
};
export type GiteaGiteaProvidersErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GiteaGiteaProvidersError = GiteaGiteaProvidersErrors[keyof GiteaGiteaProvidersErrors];
export type GiteaGiteaProvidersResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GiteaGiteaProvidersResponse = GiteaGiteaProvidersResponses[keyof GiteaGiteaProvidersResponses];
export type GiteaGetGiteaRepositoriesData = {
    body?: never;
    path?: never;
    query: {
        giteaId: string;
    };
    url: "/gitea.getGiteaRepositories";
};
export type GiteaGetGiteaRepositoriesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GiteaGetGiteaRepositoriesError = GiteaGetGiteaRepositoriesErrors[keyof GiteaGetGiteaRepositoriesErrors];
export type GiteaGetGiteaRepositoriesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GiteaGetGiteaRepositoriesResponse = GiteaGetGiteaRepositoriesResponses[keyof GiteaGetGiteaRepositoriesResponses];
export type GiteaGetGiteaBranchesData = {
    body?: never;
    path?: never;
    query: {
        owner: string;
        repositoryName: string;
        giteaId?: string;
    };
    url: "/gitea.getGiteaBranches";
};
export type GiteaGetGiteaBranchesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GiteaGetGiteaBranchesError = GiteaGetGiteaBranchesErrors[keyof GiteaGetGiteaBranchesErrors];
export type GiteaGetGiteaBranchesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GiteaGetGiteaBranchesResponse = GiteaGetGiteaBranchesResponses[keyof GiteaGetGiteaBranchesResponses];
export type GiteaTestConnectionData = {
    body: {
        giteaId?: string;
        organizationName?: string;
    };
    path?: never;
    query?: never;
    url: "/gitea.testConnection";
};
export type GiteaTestConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GiteaTestConnectionError = GiteaTestConnectionErrors[keyof GiteaTestConnectionErrors];
export type GiteaTestConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GiteaTestConnectionResponse = GiteaTestConnectionResponses[keyof GiteaTestConnectionResponses];
export type GiteaUpdateData = {
    body: {
        giteaId: string;
        giteaUrl: string;
        giteaInternalUrl?: string | null;
        redirectUri?: string;
        clientId?: string;
        clientSecret?: string;
        gitProviderId: string;
        accessToken?: string;
        refreshToken?: string;
        expiresAt?: number;
        scopes?: string;
        lastAuthenticatedAt?: number;
        name: string;
        giteaUsername?: string;
        organizationName?: string;
    };
    path?: never;
    query?: never;
    url: "/gitea.update";
};
export type GiteaUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GiteaUpdateError = GiteaUpdateErrors[keyof GiteaUpdateErrors];
export type GiteaUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GiteaUpdateResponse = GiteaUpdateResponses[keyof GiteaUpdateResponses];
export type GiteaGetGiteaUrlData = {
    body?: never;
    path?: never;
    query: {
        giteaId: string;
    };
    url: "/gitea.getGiteaUrl";
};
export type GiteaGetGiteaUrlErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GiteaGetGiteaUrlError = GiteaGetGiteaUrlErrors[keyof GiteaGetGiteaUrlErrors];
export type GiteaGetGiteaUrlResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GiteaGetGiteaUrlResponse = GiteaGetGiteaUrlResponses[keyof GiteaGetGiteaUrlResponses];
export type GitProviderGetAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/gitProvider.getAll";
};
export type GitProviderGetAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GitProviderGetAllError = GitProviderGetAllErrors[keyof GitProviderGetAllErrors];
export type GitProviderGetAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GitProviderGetAllResponse = GitProviderGetAllResponses[keyof GitProviderGetAllResponses];
export type GitProviderToggleShareData = {
    body: {
        gitProviderId: string;
        sharedWithOrganization: boolean;
    };
    path?: never;
    query?: never;
    url: "/gitProvider.toggleShare";
};
export type GitProviderToggleShareErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GitProviderToggleShareError = GitProviderToggleShareErrors[keyof GitProviderToggleShareErrors];
export type GitProviderToggleShareResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GitProviderToggleShareResponse = GitProviderToggleShareResponses[keyof GitProviderToggleShareResponses];
export type GitProviderAllForPermissionsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/gitProvider.allForPermissions";
};
export type GitProviderAllForPermissionsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GitProviderAllForPermissionsError = GitProviderAllForPermissionsErrors[keyof GitProviderAllForPermissionsErrors];
export type GitProviderAllForPermissionsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GitProviderAllForPermissionsResponse = GitProviderAllForPermissionsResponses[keyof GitProviderAllForPermissionsResponses];
export type GitProviderRemoveData = {
    body: {
        gitProviderId: string;
    };
    path?: never;
    query?: never;
    url: "/gitProvider.remove";
};
export type GitProviderRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GitProviderRemoveError = GitProviderRemoveErrors[keyof GitProviderRemoveErrors];
export type GitProviderRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GitProviderRemoveResponse = GitProviderRemoveResponses[keyof GitProviderRemoveResponses];
export type GithubOneData = {
    body?: never;
    path?: never;
    query: {
        githubId: string;
    };
    url: "/github.one";
};
export type GithubOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GithubOneError = GithubOneErrors[keyof GithubOneErrors];
export type GithubOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GithubOneResponse = GithubOneResponses[keyof GithubOneResponses];
export type GithubGetGithubRepositoriesData = {
    body?: never;
    path?: never;
    query: {
        githubId: string;
    };
    url: "/github.getGithubRepositories";
};
export type GithubGetGithubRepositoriesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GithubGetGithubRepositoriesError = GithubGetGithubRepositoriesErrors[keyof GithubGetGithubRepositoriesErrors];
export type GithubGetGithubRepositoriesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GithubGetGithubRepositoriesResponse = GithubGetGithubRepositoriesResponses[keyof GithubGetGithubRepositoriesResponses];
export type GithubGetGithubBranchesData = {
    body?: never;
    path?: never;
    query: {
        repo: string;
        owner: string;
        githubId?: string;
    };
    url: "/github.getGithubBranches";
};
export type GithubGetGithubBranchesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GithubGetGithubBranchesError = GithubGetGithubBranchesErrors[keyof GithubGetGithubBranchesErrors];
export type GithubGetGithubBranchesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GithubGetGithubBranchesResponse = GithubGetGithubBranchesResponses[keyof GithubGetGithubBranchesResponses];
export type GithubGithubProvidersData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/github.githubProviders";
};
export type GithubGithubProvidersErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GithubGithubProvidersError = GithubGithubProvidersErrors[keyof GithubGithubProvidersErrors];
export type GithubGithubProvidersResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GithubGithubProvidersResponse = GithubGithubProvidersResponses[keyof GithubGithubProvidersResponses];
export type GithubTestConnectionData = {
    body: {
        githubId: string;
    };
    path?: never;
    query?: never;
    url: "/github.testConnection";
};
export type GithubTestConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GithubTestConnectionError = GithubTestConnectionErrors[keyof GithubTestConnectionErrors];
export type GithubTestConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GithubTestConnectionResponse = GithubTestConnectionResponses[keyof GithubTestConnectionResponses];
export type GithubUpdateData = {
    body: {
        githubId: string;
        name: string;
        gitProviderId: string;
        githubAppName: string;
    };
    path?: never;
    query?: never;
    url: "/github.update";
};
export type GithubUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GithubUpdateError = GithubUpdateErrors[keyof GithubUpdateErrors];
export type GithubUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GithubUpdateResponse = GithubUpdateResponses[keyof GithubUpdateResponses];
export type GitlabCreateData = {
    body: {
        applicationId?: string;
        secret?: string;
        groupName?: string;
        gitProviderId?: string;
        redirectUri?: string;
        authId: string;
        name: string;
        gitlabUrl: string;
        gitlabInternalUrl?: string | null;
    };
    path?: never;
    query?: never;
    url: "/gitlab.create";
};
export type GitlabCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GitlabCreateError = GitlabCreateErrors[keyof GitlabCreateErrors];
export type GitlabCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GitlabCreateResponse = GitlabCreateResponses[keyof GitlabCreateResponses];
export type GitlabOneData = {
    body?: never;
    path?: never;
    query: {
        gitlabId: string;
    };
    url: "/gitlab.one";
};
export type GitlabOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GitlabOneError = GitlabOneErrors[keyof GitlabOneErrors];
export type GitlabOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GitlabOneResponse = GitlabOneResponses[keyof GitlabOneResponses];
export type GitlabGitlabProvidersData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/gitlab.gitlabProviders";
};
export type GitlabGitlabProvidersErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GitlabGitlabProvidersError = GitlabGitlabProvidersErrors[keyof GitlabGitlabProvidersErrors];
export type GitlabGitlabProvidersResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GitlabGitlabProvidersResponse = GitlabGitlabProvidersResponses[keyof GitlabGitlabProvidersResponses];
export type GitlabGetGitlabRepositoriesData = {
    body?: never;
    path?: never;
    query: {
        gitlabId: string;
    };
    url: "/gitlab.getGitlabRepositories";
};
export type GitlabGetGitlabRepositoriesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GitlabGetGitlabRepositoriesError = GitlabGetGitlabRepositoriesErrors[keyof GitlabGetGitlabRepositoriesErrors];
export type GitlabGetGitlabRepositoriesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GitlabGetGitlabRepositoriesResponse = GitlabGetGitlabRepositoriesResponses[keyof GitlabGetGitlabRepositoriesResponses];
export type GitlabGetGitlabBranchesData = {
    body?: never;
    path?: never;
    query: {
        id?: number;
        owner: string;
        repo: string;
        gitlabId?: string;
    };
    url: "/gitlab.getGitlabBranches";
};
export type GitlabGetGitlabBranchesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GitlabGetGitlabBranchesError = GitlabGetGitlabBranchesErrors[keyof GitlabGetGitlabBranchesErrors];
export type GitlabGetGitlabBranchesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GitlabGetGitlabBranchesResponse = GitlabGetGitlabBranchesResponses[keyof GitlabGetGitlabBranchesResponses];
export type GitlabTestConnectionData = {
    body: {
        gitlabId: string;
        groupName?: string;
    };
    path?: never;
    query?: never;
    url: "/gitlab.testConnection";
};
export type GitlabTestConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GitlabTestConnectionError = GitlabTestConnectionErrors[keyof GitlabTestConnectionErrors];
export type GitlabTestConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GitlabTestConnectionResponse = GitlabTestConnectionResponses[keyof GitlabTestConnectionResponses];
export type GitlabUpdateData = {
    body: {
        applicationId?: string;
        secret?: string;
        groupName?: string;
        redirectUri?: string;
        name: string;
        gitlabId: string;
        gitlabUrl: string;
        gitProviderId: string;
        gitlabInternalUrl?: string | null;
    };
    path?: never;
    query?: never;
    url: "/gitlab.update";
};
export type GitlabUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type GitlabUpdateError = GitlabUpdateErrors[keyof GitlabUpdateErrors];
export type GitlabUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type GitlabUpdateResponse = GitlabUpdateResponses[keyof GitlabUpdateResponses];
export type LibsqlCreateData = {
    body: {
        name: string;
        appName: string;
        dockerImage: string;
        environmentId: string;
        description: string | null;
        databaseUser: string;
        databasePassword: string;
        sqldNode: "primary" | "replica";
        sqldPrimaryUrl: string | null | null;
        enableNamespaces: boolean;
        serverId: string | null;
    };
    path?: never;
    query?: never;
    url: "/libsql.create";
};
export type LibsqlCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LibsqlCreateError = LibsqlCreateErrors[keyof LibsqlCreateErrors];
export type LibsqlCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LibsqlCreateResponse = LibsqlCreateResponses[keyof LibsqlCreateResponses];
export type LibsqlOneData = {
    body?: never;
    path?: never;
    query: {
        libsqlId: string;
    };
    url: "/libsql.one";
};
export type LibsqlOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LibsqlOneError = LibsqlOneErrors[keyof LibsqlOneErrors];
export type LibsqlOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LibsqlOneResponse = LibsqlOneResponses[keyof LibsqlOneResponses];
export type LibsqlStartData = {
    body: {
        libsqlId: string;
    };
    path?: never;
    query?: never;
    url: "/libsql.start";
};
export type LibsqlStartErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LibsqlStartError = LibsqlStartErrors[keyof LibsqlStartErrors];
export type LibsqlStartResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LibsqlStartResponse = LibsqlStartResponses[keyof LibsqlStartResponses];
export type LibsqlStopData = {
    body: {
        libsqlId: string;
    };
    path?: never;
    query?: never;
    url: "/libsql.stop";
};
export type LibsqlStopErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LibsqlStopError = LibsqlStopErrors[keyof LibsqlStopErrors];
export type LibsqlStopResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LibsqlStopResponse = LibsqlStopResponses[keyof LibsqlStopResponses];
export type LibsqlSaveExternalPortsData = {
    body: {
        libsqlId: string;
        externalPort?: number | null;
        externalGRPCPort?: number | null;
        externalAdminPort?: number | null;
    };
    path?: never;
    query?: never;
    url: "/libsql.saveExternalPorts";
};
export type LibsqlSaveExternalPortsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LibsqlSaveExternalPortsError = LibsqlSaveExternalPortsErrors[keyof LibsqlSaveExternalPortsErrors];
export type LibsqlSaveExternalPortsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LibsqlSaveExternalPortsResponse = LibsqlSaveExternalPortsResponses[keyof LibsqlSaveExternalPortsResponses];
export type LibsqlDeployData = {
    body: {
        libsqlId: string;
    };
    path?: never;
    query?: never;
    url: "/libsql.deploy";
};
export type LibsqlDeployErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LibsqlDeployError = LibsqlDeployErrors[keyof LibsqlDeployErrors];
export type LibsqlDeployResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LibsqlDeployResponse = LibsqlDeployResponses[keyof LibsqlDeployResponses];
export type LibsqlChangeStatusData = {
    body: {
        libsqlId: string;
        applicationStatus: "idle" | "running" | "done" | "error";
    };
    path?: never;
    query?: never;
    url: "/libsql.changeStatus";
};
export type LibsqlChangeStatusErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LibsqlChangeStatusError = LibsqlChangeStatusErrors[keyof LibsqlChangeStatusErrors];
export type LibsqlChangeStatusResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LibsqlChangeStatusResponse = LibsqlChangeStatusResponses[keyof LibsqlChangeStatusResponses];
export type LibsqlRemoveData = {
    body: {
        libsqlId: string;
    };
    path?: never;
    query?: never;
    url: "/libsql.remove";
};
export type LibsqlRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LibsqlRemoveError = LibsqlRemoveErrors[keyof LibsqlRemoveErrors];
export type LibsqlRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LibsqlRemoveResponse = LibsqlRemoveResponses[keyof LibsqlRemoveResponses];
export type LibsqlSaveEnvironmentData = {
    body: {
        libsqlId: string;
        env: string | null;
    };
    path?: never;
    query?: never;
    url: "/libsql.saveEnvironment";
};
export type LibsqlSaveEnvironmentErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LibsqlSaveEnvironmentError = LibsqlSaveEnvironmentErrors[keyof LibsqlSaveEnvironmentErrors];
export type LibsqlSaveEnvironmentResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LibsqlSaveEnvironmentResponse = LibsqlSaveEnvironmentResponses[keyof LibsqlSaveEnvironmentResponses];
export type LibsqlReloadData = {
    body: {
        libsqlId: string;
        appName: string;
    };
    path?: never;
    query?: never;
    url: "/libsql.reload";
};
export type LibsqlReloadErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LibsqlReloadError = LibsqlReloadErrors[keyof LibsqlReloadErrors];
export type LibsqlReloadResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LibsqlReloadResponse = LibsqlReloadResponses[keyof LibsqlReloadResponses];
export type LibsqlUpdateData = {
    body: {
        libsqlId: string;
        name?: string;
        appName?: string;
        description?: string | null;
        databaseUser?: string;
        databasePassword?: string;
        sqldNode?: "primary" | "replica";
        sqldPrimaryUrl?: string | null | null;
        enableNamespaces?: boolean;
        dockerImage?: string;
        command?: string | null;
        env?: string | null;
        memoryReservation?: string | null;
        memoryLimit?: string | null;
        cpuReservation?: string | null;
        cpuLimit?: string | null;
        externalPort?: number | null;
        externalGRPCPort?: number | null;
        externalAdminPort?: number | null;
        applicationStatus?: "idle" | "running" | "done" | "error";
        healthCheckSwarm?: {
            Test?: Array<string>;
            Interval?: number;
            Timeout?: number;
            StartPeriod?: number;
            Retries?: number;
        } | null | null;
        restartPolicySwarm?: {
            Condition?: string;
            Delay?: number;
            MaxAttempts?: number;
            Window?: number;
        } | null | null;
        placementSwarm?: {
            Constraints?: Array<string>;
            Preferences?: Array<{
                Spread: {
                    SpreadDescriptor: string;
                };
            }>;
            MaxReplicas?: number;
            Platforms?: Array<{
                Architecture: string;
                OS: string;
            }>;
        } | null | null;
        updateConfigSwarm?: {
            Parallelism: number;
            Delay?: number;
            FailureAction?: string;
            Monitor?: number;
            MaxFailureRatio?: number;
            Order: string;
        } | null | null;
        rollbackConfigSwarm?: {
            Parallelism: number;
            Delay?: number;
            FailureAction?: string;
            Monitor?: number;
            MaxFailureRatio?: number;
            Order: string;
        } | null | null;
        modeSwarm?: {
            Replicated?: {
                Replicas?: number;
            };
            Global?: {
                [key: string]: unknown;
            };
            ReplicatedJob?: {
                MaxConcurrent?: number;
                TotalCompletions?: number;
            };
            GlobalJob?: {
                [key: string]: unknown;
            };
        } | null | null;
        labelsSwarm?: {
            [key: string]: string;
        } | null | null;
        networkSwarm?: Array<{
            Target?: string;
            Aliases?: Array<string>;
            DriverOpts?: {
                [key: string]: string;
            };
        }> | null | null;
        stopGracePeriodSwarm?: number | null | null;
        endpointSpecSwarm?: {
            Mode?: string;
            Ports?: Array<{
                Protocol?: string;
                TargetPort?: number;
                PublishedPort?: number;
                PublishMode?: string;
            }>;
        } | null | null;
        replicas?: number;
        networkIds?: Array<string> | null;
        detachDokployNetwork?: boolean;
        createdAt?: string;
        environmentId?: string;
    };
    path?: never;
    query?: never;
    url: "/libsql.update";
};
export type LibsqlUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LibsqlUpdateError = LibsqlUpdateErrors[keyof LibsqlUpdateErrors];
export type LibsqlUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LibsqlUpdateResponse = LibsqlUpdateResponses[keyof LibsqlUpdateResponses];
export type LibsqlMoveData = {
    body: {
        libsqlId: string;
        targetEnvironmentId: string;
    };
    path?: never;
    query?: never;
    url: "/libsql.move";
};
export type LibsqlMoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LibsqlMoveError = LibsqlMoveErrors[keyof LibsqlMoveErrors];
export type LibsqlMoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LibsqlMoveResponse = LibsqlMoveResponses[keyof LibsqlMoveResponses];
export type LibsqlRebuildData = {
    body: {
        libsqlId: string;
    };
    path?: never;
    query?: never;
    url: "/libsql.rebuild";
};
export type LibsqlRebuildErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LibsqlRebuildError = LibsqlRebuildErrors[keyof LibsqlRebuildErrors];
export type LibsqlRebuildResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LibsqlRebuildResponse = LibsqlRebuildResponses[keyof LibsqlRebuildResponses];
export type LibsqlReadLogsData = {
    body?: never;
    path?: never;
    query: {
        libsqlId: string;
        tail?: number;
        since?: string;
        search?: string;
    };
    url: "/libsql.readLogs";
};
export type LibsqlReadLogsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LibsqlReadLogsError = LibsqlReadLogsErrors[keyof LibsqlReadLogsErrors];
export type LibsqlReadLogsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LibsqlReadLogsResponse = LibsqlReadLogsResponses[keyof LibsqlReadLogsResponses];
export type MariadbCreateData = {
    body: {
        name: string;
        appName?: string;
        dockerImage?: string;
        databaseRootPassword?: string;
        environmentId: string;
        description?: string | null;
        databaseName: string;
        databaseUser: string;
        databasePassword: string;
        serverId?: string | null;
    };
    path?: never;
    query?: never;
    url: "/mariadb.create";
};
export type MariadbCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbCreateError = MariadbCreateErrors[keyof MariadbCreateErrors];
export type MariadbCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbCreateResponse = MariadbCreateResponses[keyof MariadbCreateResponses];
export type MariadbOneData = {
    body?: never;
    path?: never;
    query: {
        mariadbId: string;
    };
    url: "/mariadb.one";
};
export type MariadbOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbOneError = MariadbOneErrors[keyof MariadbOneErrors];
export type MariadbOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbOneResponse = MariadbOneResponses[keyof MariadbOneResponses];
export type MariadbStartData = {
    body: {
        mariadbId: string;
    };
    path?: never;
    query?: never;
    url: "/mariadb.start";
};
export type MariadbStartErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbStartError = MariadbStartErrors[keyof MariadbStartErrors];
export type MariadbStartResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbStartResponse = MariadbStartResponses[keyof MariadbStartResponses];
export type MariadbStopData = {
    body: {
        mariadbId: string;
    };
    path?: never;
    query?: never;
    url: "/mariadb.stop";
};
export type MariadbStopErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbStopError = MariadbStopErrors[keyof MariadbStopErrors];
export type MariadbStopResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbStopResponse = MariadbStopResponses[keyof MariadbStopResponses];
export type MariadbSaveExternalPortData = {
    body: {
        mariadbId: string;
        externalPort: number | null;
    };
    path?: never;
    query?: never;
    url: "/mariadb.saveExternalPort";
};
export type MariadbSaveExternalPortErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbSaveExternalPortError = MariadbSaveExternalPortErrors[keyof MariadbSaveExternalPortErrors];
export type MariadbSaveExternalPortResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbSaveExternalPortResponse = MariadbSaveExternalPortResponses[keyof MariadbSaveExternalPortResponses];
export type MariadbDeployData = {
    body: {
        mariadbId: string;
    };
    path?: never;
    query?: never;
    url: "/mariadb.deploy";
};
export type MariadbDeployErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbDeployError = MariadbDeployErrors[keyof MariadbDeployErrors];
export type MariadbDeployResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbDeployResponse = MariadbDeployResponses[keyof MariadbDeployResponses];
export type MariadbChangeStatusData = {
    body: {
        mariadbId: string;
        applicationStatus: "idle" | "running" | "done" | "error";
    };
    path?: never;
    query?: never;
    url: "/mariadb.changeStatus";
};
export type MariadbChangeStatusErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbChangeStatusError = MariadbChangeStatusErrors[keyof MariadbChangeStatusErrors];
export type MariadbChangeStatusResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbChangeStatusResponse = MariadbChangeStatusResponses[keyof MariadbChangeStatusResponses];
export type MariadbRemoveData = {
    body: {
        mariadbId: string;
    };
    path?: never;
    query?: never;
    url: "/mariadb.remove";
};
export type MariadbRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbRemoveError = MariadbRemoveErrors[keyof MariadbRemoveErrors];
export type MariadbRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbRemoveResponse = MariadbRemoveResponses[keyof MariadbRemoveResponses];
export type MariadbSaveEnvironmentData = {
    body: {
        mariadbId: string;
        env: string | null;
    };
    path?: never;
    query?: never;
    url: "/mariadb.saveEnvironment";
};
export type MariadbSaveEnvironmentErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbSaveEnvironmentError = MariadbSaveEnvironmentErrors[keyof MariadbSaveEnvironmentErrors];
export type MariadbSaveEnvironmentResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbSaveEnvironmentResponse = MariadbSaveEnvironmentResponses[keyof MariadbSaveEnvironmentResponses];
export type MariadbReloadData = {
    body: {
        mariadbId: string;
        appName: string;
    };
    path?: never;
    query?: never;
    url: "/mariadb.reload";
};
export type MariadbReloadErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbReloadError = MariadbReloadErrors[keyof MariadbReloadErrors];
export type MariadbReloadResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbReloadResponse = MariadbReloadResponses[keyof MariadbReloadResponses];
export type MariadbUpdateData = {
    body: {
        mariadbId: string;
        name?: string;
        appName?: string;
        description?: string | null;
        databaseName?: string;
        databaseUser?: string;
        databasePassword?: string;
        databaseRootPassword?: string;
        dockerImage?: string;
        command?: string | null;
        args?: Array<string> | null;
        env?: string | null;
        memoryReservation?: string | null;
        memoryLimit?: string | null;
        cpuReservation?: string | null;
        cpuLimit?: string | null;
        externalPort?: number | null;
        applicationStatus?: "idle" | "running" | "done" | "error";
        healthCheckSwarm?: {
            Test?: Array<string>;
            Interval?: number;
            Timeout?: number;
            StartPeriod?: number;
            Retries?: number;
        } | null | null;
        restartPolicySwarm?: {
            Condition?: string;
            Delay?: number;
            MaxAttempts?: number;
            Window?: number;
        } | null | null;
        placementSwarm?: {
            Constraints?: Array<string>;
            Preferences?: Array<{
                Spread: {
                    SpreadDescriptor: string;
                };
            }>;
            MaxReplicas?: number;
            Platforms?: Array<{
                Architecture: string;
                OS: string;
            }>;
        } | null | null;
        updateConfigSwarm?: {
            Parallelism: number;
            Delay?: number;
            FailureAction?: string;
            Monitor?: number;
            MaxFailureRatio?: number;
            Order: string;
        } | null | null;
        rollbackConfigSwarm?: {
            Parallelism: number;
            Delay?: number;
            FailureAction?: string;
            Monitor?: number;
            MaxFailureRatio?: number;
            Order: string;
        } | null | null;
        modeSwarm?: {
            Replicated?: {
                Replicas?: number;
            };
            Global?: {
                [key: string]: unknown;
            };
            ReplicatedJob?: {
                MaxConcurrent?: number;
                TotalCompletions?: number;
            };
            GlobalJob?: {
                [key: string]: unknown;
            };
        } | null | null;
        labelsSwarm?: {
            [key: string]: string;
        } | null | null;
        networkSwarm?: Array<{
            Target?: string;
            Aliases?: Array<string>;
            DriverOpts?: {
                [key: string]: string;
            };
        }> | null | null;
        stopGracePeriodSwarm?: number | null | null;
        endpointSpecSwarm?: {
            Mode?: string;
            Ports?: Array<{
                Protocol?: string;
                TargetPort?: number;
                PublishedPort?: number;
                PublishMode?: string;
            }>;
        } | null | null;
        ulimitsSwarm?: Array<{
            Name: string;
            Soft: number;
            Hard: number;
        }> | null | null;
        replicas?: number;
        createdAt?: string;
        environmentId?: string;
        networkIds?: Array<string> | null;
        detachDokployNetwork?: boolean;
    };
    path?: never;
    query?: never;
    url: "/mariadb.update";
};
export type MariadbUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbUpdateError = MariadbUpdateErrors[keyof MariadbUpdateErrors];
export type MariadbUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbUpdateResponse = MariadbUpdateResponses[keyof MariadbUpdateResponses];
export type MariadbChangePasswordData = {
    body: {
        mariadbId: string;
        password: string;
        type?: "user" | "root";
    };
    path?: never;
    query?: never;
    url: "/mariadb.changePassword";
};
export type MariadbChangePasswordErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbChangePasswordError = MariadbChangePasswordErrors[keyof MariadbChangePasswordErrors];
export type MariadbChangePasswordResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbChangePasswordResponse = MariadbChangePasswordResponses[keyof MariadbChangePasswordResponses];
export type MariadbMoveData = {
    body: {
        mariadbId: string;
        targetEnvironmentId: string;
    };
    path?: never;
    query?: never;
    url: "/mariadb.move";
};
export type MariadbMoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbMoveError = MariadbMoveErrors[keyof MariadbMoveErrors];
export type MariadbMoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbMoveResponse = MariadbMoveResponses[keyof MariadbMoveResponses];
export type MariadbRebuildData = {
    body: {
        mariadbId: string;
    };
    path?: never;
    query?: never;
    url: "/mariadb.rebuild";
};
export type MariadbRebuildErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbRebuildError = MariadbRebuildErrors[keyof MariadbRebuildErrors];
export type MariadbRebuildResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbRebuildResponse = MariadbRebuildResponses[keyof MariadbRebuildResponses];
export type MariadbSearchData = {
    body?: never;
    path?: never;
    query?: {
        q?: string;
        name?: string;
        appName?: string;
        description?: string;
        projectId?: string;
        environmentId?: string;
        limit?: number;
        offset?: number;
    };
    url: "/mariadb.search";
};
export type MariadbSearchErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbSearchError = MariadbSearchErrors[keyof MariadbSearchErrors];
export type MariadbSearchResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbSearchResponse = MariadbSearchResponses[keyof MariadbSearchResponses];
export type MariadbReadLogsData = {
    body?: never;
    path?: never;
    query: {
        mariadbId: string;
        tail?: number;
        since?: string;
        search?: string;
    };
    url: "/mariadb.readLogs";
};
export type MariadbReadLogsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MariadbReadLogsError = MariadbReadLogsErrors[keyof MariadbReadLogsErrors];
export type MariadbReadLogsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MariadbReadLogsResponse = MariadbReadLogsResponses[keyof MariadbReadLogsResponses];
export type MongoCreateData = {
    body: {
        name: string;
        appName?: string;
        dockerImage?: string;
        environmentId: string;
        description?: string | null;
        databaseUser: string;
        databasePassword: string;
        serverId?: string | null;
        replicaSets?: boolean | null;
    };
    path?: never;
    query?: never;
    url: "/mongo.create";
};
export type MongoCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoCreateError = MongoCreateErrors[keyof MongoCreateErrors];
export type MongoCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoCreateResponse = MongoCreateResponses[keyof MongoCreateResponses];
export type MongoOneData = {
    body?: never;
    path?: never;
    query: {
        mongoId: string;
    };
    url: "/mongo.one";
};
export type MongoOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoOneError = MongoOneErrors[keyof MongoOneErrors];
export type MongoOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoOneResponse = MongoOneResponses[keyof MongoOneResponses];
export type MongoStartData = {
    body: {
        mongoId: string;
    };
    path?: never;
    query?: never;
    url: "/mongo.start";
};
export type MongoStartErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoStartError = MongoStartErrors[keyof MongoStartErrors];
export type MongoStartResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoStartResponse = MongoStartResponses[keyof MongoStartResponses];
export type MongoStopData = {
    body: {
        mongoId: string;
    };
    path?: never;
    query?: never;
    url: "/mongo.stop";
};
export type MongoStopErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoStopError = MongoStopErrors[keyof MongoStopErrors];
export type MongoStopResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoStopResponse = MongoStopResponses[keyof MongoStopResponses];
export type MongoSaveExternalPortData = {
    body: {
        mongoId: string;
        externalPort: number | null;
    };
    path?: never;
    query?: never;
    url: "/mongo.saveExternalPort";
};
export type MongoSaveExternalPortErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoSaveExternalPortError = MongoSaveExternalPortErrors[keyof MongoSaveExternalPortErrors];
export type MongoSaveExternalPortResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoSaveExternalPortResponse = MongoSaveExternalPortResponses[keyof MongoSaveExternalPortResponses];
export type MongoDeployData = {
    body: {
        mongoId: string;
    };
    path?: never;
    query?: never;
    url: "/mongo.deploy";
};
export type MongoDeployErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoDeployError = MongoDeployErrors[keyof MongoDeployErrors];
export type MongoDeployResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoDeployResponse = MongoDeployResponses[keyof MongoDeployResponses];
export type MongoChangeStatusData = {
    body: {
        mongoId: string;
        applicationStatus: "idle" | "running" | "done" | "error";
    };
    path?: never;
    query?: never;
    url: "/mongo.changeStatus";
};
export type MongoChangeStatusErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoChangeStatusError = MongoChangeStatusErrors[keyof MongoChangeStatusErrors];
export type MongoChangeStatusResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoChangeStatusResponse = MongoChangeStatusResponses[keyof MongoChangeStatusResponses];
export type MongoReloadData = {
    body: {
        mongoId: string;
        appName: string;
    };
    path?: never;
    query?: never;
    url: "/mongo.reload";
};
export type MongoReloadErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoReloadError = MongoReloadErrors[keyof MongoReloadErrors];
export type MongoReloadResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoReloadResponse = MongoReloadResponses[keyof MongoReloadResponses];
export type MongoRemoveData = {
    body: {
        mongoId: string;
    };
    path?: never;
    query?: never;
    url: "/mongo.remove";
};
export type MongoRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoRemoveError = MongoRemoveErrors[keyof MongoRemoveErrors];
export type MongoRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoRemoveResponse = MongoRemoveResponses[keyof MongoRemoveResponses];
export type MongoSaveEnvironmentData = {
    body: {
        mongoId: string;
        env: string | null;
    };
    path?: never;
    query?: never;
    url: "/mongo.saveEnvironment";
};
export type MongoSaveEnvironmentErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoSaveEnvironmentError = MongoSaveEnvironmentErrors[keyof MongoSaveEnvironmentErrors];
export type MongoSaveEnvironmentResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoSaveEnvironmentResponse = MongoSaveEnvironmentResponses[keyof MongoSaveEnvironmentResponses];
export type MongoUpdateData = {
    body: {
        mongoId: string;
        name?: string;
        appName?: string;
        description?: string | null;
        databaseUser?: string;
        databasePassword?: string;
        dockerImage?: string;
        command?: string | null;
        args?: Array<string> | null;
        env?: string | null;
        memoryReservation?: string | null;
        memoryLimit?: string | null;
        cpuReservation?: string | null;
        cpuLimit?: string | null;
        externalPort?: number | null;
        applicationStatus?: "idle" | "running" | "done" | "error";
        healthCheckSwarm?: {
            Test?: Array<string>;
            Interval?: number;
            Timeout?: number;
            StartPeriod?: number;
            Retries?: number;
        } | null | null;
        restartPolicySwarm?: {
            Condition?: string;
            Delay?: number;
            MaxAttempts?: number;
            Window?: number;
        } | null | null;
        placementSwarm?: {
            Constraints?: Array<string>;
            Preferences?: Array<{
                Spread: {
                    SpreadDescriptor: string;
                };
            }>;
            MaxReplicas?: number;
            Platforms?: Array<{
                Architecture: string;
                OS: string;
            }>;
        } | null | null;
        updateConfigSwarm?: {
            Parallelism: number;
            Delay?: number;
            FailureAction?: string;
            Monitor?: number;
            MaxFailureRatio?: number;
            Order: string;
        } | null | null;
        rollbackConfigSwarm?: {
            Parallelism: number;
            Delay?: number;
            FailureAction?: string;
            Monitor?: number;
            MaxFailureRatio?: number;
            Order: string;
        } | null | null;
        modeSwarm?: {
            Replicated?: {
                Replicas?: number;
            };
            Global?: {
                [key: string]: unknown;
            };
            ReplicatedJob?: {
                MaxConcurrent?: number;
                TotalCompletions?: number;
            };
            GlobalJob?: {
                [key: string]: unknown;
            };
        } | null | null;
        labelsSwarm?: {
            [key: string]: string;
        } | null | null;
        networkSwarm?: Array<{
            Target?: string;
            Aliases?: Array<string>;
            DriverOpts?: {
                [key: string]: string;
            };
        }> | null | null;
        stopGracePeriodSwarm?: number | null | null;
        endpointSpecSwarm?: {
            Mode?: string;
            Ports?: Array<{
                Protocol?: string;
                TargetPort?: number;
                PublishedPort?: number;
                PublishMode?: string;
            }>;
        } | null | null;
        ulimitsSwarm?: Array<{
            Name: string;
            Soft: number;
            Hard: number;
        }> | null | null;
        replicas?: number;
        createdAt?: string;
        environmentId?: string;
        replicaSets?: boolean;
        networkIds?: Array<string> | null;
        detachDokployNetwork?: boolean;
    };
    path?: never;
    query?: never;
    url: "/mongo.update";
};
export type MongoUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoUpdateError = MongoUpdateErrors[keyof MongoUpdateErrors];
export type MongoUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoUpdateResponse = MongoUpdateResponses[keyof MongoUpdateResponses];
export type MongoChangePasswordData = {
    body: {
        mongoId: string;
        password: string;
    };
    path?: never;
    query?: never;
    url: "/mongo.changePassword";
};
export type MongoChangePasswordErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoChangePasswordError = MongoChangePasswordErrors[keyof MongoChangePasswordErrors];
export type MongoChangePasswordResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoChangePasswordResponse = MongoChangePasswordResponses[keyof MongoChangePasswordResponses];
export type MongoMoveData = {
    body: {
        mongoId: string;
        targetEnvironmentId: string;
    };
    path?: never;
    query?: never;
    url: "/mongo.move";
};
export type MongoMoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoMoveError = MongoMoveErrors[keyof MongoMoveErrors];
export type MongoMoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoMoveResponse = MongoMoveResponses[keyof MongoMoveResponses];
export type MongoRebuildData = {
    body: {
        mongoId: string;
    };
    path?: never;
    query?: never;
    url: "/mongo.rebuild";
};
export type MongoRebuildErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoRebuildError = MongoRebuildErrors[keyof MongoRebuildErrors];
export type MongoRebuildResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoRebuildResponse = MongoRebuildResponses[keyof MongoRebuildResponses];
export type MongoSearchData = {
    body?: never;
    path?: never;
    query?: {
        q?: string;
        name?: string;
        appName?: string;
        description?: string;
        projectId?: string;
        environmentId?: string;
        limit?: number;
        offset?: number;
    };
    url: "/mongo.search";
};
export type MongoSearchErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoSearchError = MongoSearchErrors[keyof MongoSearchErrors];
export type MongoSearchResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoSearchResponse = MongoSearchResponses[keyof MongoSearchResponses];
export type MongoReadLogsData = {
    body?: never;
    path?: never;
    query: {
        mongoId: string;
        tail?: number;
        since?: string;
        search?: string;
    };
    url: "/mongo.readLogs";
};
export type MongoReadLogsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MongoReadLogsError = MongoReadLogsErrors[keyof MongoReadLogsErrors];
export type MongoReadLogsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MongoReadLogsResponse = MongoReadLogsResponses[keyof MongoReadLogsResponses];
export type MountsCreateData = {
    body: {
        type: "bind" | "volume" | "file";
        hostPath?: string | null;
        volumeName?: string | null;
        content?: string | null;
        mountPath: string;
        filePath?: string | null;
        serviceType?: "application" | "postgres" | "mysql" | "mariadb" | "mongo" | "redis" | "compose" | "libsql";
        serviceId: string;
    };
    path?: never;
    query?: never;
    url: "/mounts.create";
};
export type MountsCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MountsCreateError = MountsCreateErrors[keyof MountsCreateErrors];
export type MountsCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MountsCreateResponse = MountsCreateResponses[keyof MountsCreateResponses];
export type MountsRemoveData = {
    body: {
        mountId: string;
    };
    path?: never;
    query?: never;
    url: "/mounts.remove";
};
export type MountsRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MountsRemoveError = MountsRemoveErrors[keyof MountsRemoveErrors];
export type MountsRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MountsRemoveResponse = MountsRemoveResponses[keyof MountsRemoveResponses];
export type MountsOneData = {
    body?: never;
    path?: never;
    query: {
        mountId: string;
    };
    url: "/mounts.one";
};
export type MountsOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MountsOneError = MountsOneErrors[keyof MountsOneErrors];
export type MountsOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MountsOneResponse = MountsOneResponses[keyof MountsOneResponses];
export type MountsUpdateData = {
    body: {
        mountId: string;
        type?: "bind" | "volume" | "file";
        hostPath?: string | null;
        volumeName?: string | null;
        filePath?: string | null;
        content?: string | null;
        serviceType?: "application" | "postgres" | "mysql" | "mariadb" | "mongo" | "redis" | "compose" | "libsql";
        mountPath?: string;
        applicationId?: string | null;
        composeId?: string | null;
        libsqlId?: string | null;
        mariadbId?: string | null;
        mongoId?: string | null;
        mysqlId?: string | null;
        postgresId?: string | null;
        redisId?: string | null;
    };
    path?: never;
    query?: never;
    url: "/mounts.update";
};
export type MountsUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MountsUpdateError = MountsUpdateErrors[keyof MountsUpdateErrors];
export type MountsUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MountsUpdateResponse = MountsUpdateResponses[keyof MountsUpdateResponses];
export type MountsAllNamedByApplicationIdData = {
    body?: never;
    path?: never;
    query: {
        applicationId: string;
    };
    url: "/mounts.allNamedByApplicationId";
};
export type MountsAllNamedByApplicationIdErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MountsAllNamedByApplicationIdError = MountsAllNamedByApplicationIdErrors[keyof MountsAllNamedByApplicationIdErrors];
export type MountsAllNamedByApplicationIdResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MountsAllNamedByApplicationIdResponse = MountsAllNamedByApplicationIdResponses[keyof MountsAllNamedByApplicationIdResponses];
export type MountsListByServiceIdData = {
    body?: never;
    path?: never;
    query: {
        serviceType: string;
        serviceId: string;
    };
    url: "/mounts.listByServiceId";
};
export type MountsListByServiceIdErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MountsListByServiceIdError = MountsListByServiceIdErrors[keyof MountsListByServiceIdErrors];
export type MountsListByServiceIdResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MountsListByServiceIdResponse = MountsListByServiceIdResponses[keyof MountsListByServiceIdResponses];
export type MysqlCreateData = {
    body: {
        name: string;
        appName?: string;
        dockerImage?: string;
        environmentId: string;
        description?: string | null;
        databaseName: string;
        databaseUser: string;
        databasePassword: string;
        databaseRootPassword?: string;
        serverId?: string | null;
    };
    path?: never;
    query?: never;
    url: "/mysql.create";
};
export type MysqlCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlCreateError = MysqlCreateErrors[keyof MysqlCreateErrors];
export type MysqlCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlCreateResponse = MysqlCreateResponses[keyof MysqlCreateResponses];
export type MysqlOneData = {
    body?: never;
    path?: never;
    query: {
        mysqlId: string;
    };
    url: "/mysql.one";
};
export type MysqlOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlOneError = MysqlOneErrors[keyof MysqlOneErrors];
export type MysqlOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlOneResponse = MysqlOneResponses[keyof MysqlOneResponses];
export type MysqlStartData = {
    body: {
        mysqlId: string;
    };
    path?: never;
    query?: never;
    url: "/mysql.start";
};
export type MysqlStartErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlStartError = MysqlStartErrors[keyof MysqlStartErrors];
export type MysqlStartResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlStartResponse = MysqlStartResponses[keyof MysqlStartResponses];
export type MysqlStopData = {
    body: {
        mysqlId: string;
    };
    path?: never;
    query?: never;
    url: "/mysql.stop";
};
export type MysqlStopErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlStopError = MysqlStopErrors[keyof MysqlStopErrors];
export type MysqlStopResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlStopResponse = MysqlStopResponses[keyof MysqlStopResponses];
export type MysqlSaveExternalPortData = {
    body: {
        mysqlId: string;
        externalPort: number | null;
    };
    path?: never;
    query?: never;
    url: "/mysql.saveExternalPort";
};
export type MysqlSaveExternalPortErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlSaveExternalPortError = MysqlSaveExternalPortErrors[keyof MysqlSaveExternalPortErrors];
export type MysqlSaveExternalPortResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlSaveExternalPortResponse = MysqlSaveExternalPortResponses[keyof MysqlSaveExternalPortResponses];
export type MysqlDeployData = {
    body: {
        mysqlId: string;
    };
    path?: never;
    query?: never;
    url: "/mysql.deploy";
};
export type MysqlDeployErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlDeployError = MysqlDeployErrors[keyof MysqlDeployErrors];
export type MysqlDeployResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlDeployResponse = MysqlDeployResponses[keyof MysqlDeployResponses];
export type MysqlChangeStatusData = {
    body: {
        mysqlId: string;
        applicationStatus: "idle" | "running" | "done" | "error";
    };
    path?: never;
    query?: never;
    url: "/mysql.changeStatus";
};
export type MysqlChangeStatusErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlChangeStatusError = MysqlChangeStatusErrors[keyof MysqlChangeStatusErrors];
export type MysqlChangeStatusResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlChangeStatusResponse = MysqlChangeStatusResponses[keyof MysqlChangeStatusResponses];
export type MysqlReloadData = {
    body: {
        mysqlId: string;
        appName: string;
    };
    path?: never;
    query?: never;
    url: "/mysql.reload";
};
export type MysqlReloadErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlReloadError = MysqlReloadErrors[keyof MysqlReloadErrors];
export type MysqlReloadResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlReloadResponse = MysqlReloadResponses[keyof MysqlReloadResponses];
export type MysqlRemoveData = {
    body: {
        mysqlId: string;
    };
    path?: never;
    query?: never;
    url: "/mysql.remove";
};
export type MysqlRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlRemoveError = MysqlRemoveErrors[keyof MysqlRemoveErrors];
export type MysqlRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlRemoveResponse = MysqlRemoveResponses[keyof MysqlRemoveResponses];
export type MysqlSaveEnvironmentData = {
    body: {
        mysqlId: string;
        env: string | null;
    };
    path?: never;
    query?: never;
    url: "/mysql.saveEnvironment";
};
export type MysqlSaveEnvironmentErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlSaveEnvironmentError = MysqlSaveEnvironmentErrors[keyof MysqlSaveEnvironmentErrors];
export type MysqlSaveEnvironmentResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlSaveEnvironmentResponse = MysqlSaveEnvironmentResponses[keyof MysqlSaveEnvironmentResponses];
export type MysqlUpdateData = {
    body: {
        mysqlId: string;
        name?: string;
        appName?: string;
        description?: string | null;
        databaseName?: string;
        databaseUser?: string;
        databasePassword?: string;
        databaseRootPassword?: string;
        dockerImage?: string;
        command?: string | null;
        args?: Array<string> | null;
        env?: string | null;
        memoryReservation?: string | null;
        memoryLimit?: string | null;
        cpuReservation?: string | null;
        cpuLimit?: string | null;
        externalPort?: number | null;
        applicationStatus?: "idle" | "running" | "done" | "error";
        healthCheckSwarm?: {
            Test?: Array<string>;
            Interval?: number;
            Timeout?: number;
            StartPeriod?: number;
            Retries?: number;
        } | null | null;
        restartPolicySwarm?: {
            Condition?: string;
            Delay?: number;
            MaxAttempts?: number;
            Window?: number;
        } | null | null;
        placementSwarm?: {
            Constraints?: Array<string>;
            Preferences?: Array<{
                Spread: {
                    SpreadDescriptor: string;
                };
            }>;
            MaxReplicas?: number;
            Platforms?: Array<{
                Architecture: string;
                OS: string;
            }>;
        } | null | null;
        updateConfigSwarm?: {
            Parallelism: number;
            Delay?: number;
            FailureAction?: string;
            Monitor?: number;
            MaxFailureRatio?: number;
            Order: string;
        } | null | null;
        rollbackConfigSwarm?: {
            Parallelism: number;
            Delay?: number;
            FailureAction?: string;
            Monitor?: number;
            MaxFailureRatio?: number;
            Order: string;
        } | null | null;
        modeSwarm?: {
            Replicated?: {
                Replicas?: number;
            };
            Global?: {
                [key: string]: unknown;
            };
            ReplicatedJob?: {
                MaxConcurrent?: number;
                TotalCompletions?: number;
            };
            GlobalJob?: {
                [key: string]: unknown;
            };
        } | null | null;
        labelsSwarm?: {
            [key: string]: string;
        } | null | null;
        networkSwarm?: Array<{
            Target?: string;
            Aliases?: Array<string>;
            DriverOpts?: {
                [key: string]: string;
            };
        }> | null | null;
        stopGracePeriodSwarm?: number | null | null;
        endpointSpecSwarm?: {
            Mode?: string;
            Ports?: Array<{
                Protocol?: string;
                TargetPort?: number;
                PublishedPort?: number;
                PublishMode?: string;
            }>;
        } | null | null;
        ulimitsSwarm?: Array<{
            Name: string;
            Soft: number;
            Hard: number;
        }> | null | null;
        replicas?: number;
        createdAt?: string;
        environmentId?: string;
        networkIds?: Array<string> | null;
        detachDokployNetwork?: boolean;
    };
    path?: never;
    query?: never;
    url: "/mysql.update";
};
export type MysqlUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlUpdateError = MysqlUpdateErrors[keyof MysqlUpdateErrors];
export type MysqlUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlUpdateResponse = MysqlUpdateResponses[keyof MysqlUpdateResponses];
export type MysqlChangePasswordData = {
    body: {
        mysqlId: string;
        password: string;
        type?: "user" | "root";
    };
    path?: never;
    query?: never;
    url: "/mysql.changePassword";
};
export type MysqlChangePasswordErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlChangePasswordError = MysqlChangePasswordErrors[keyof MysqlChangePasswordErrors];
export type MysqlChangePasswordResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlChangePasswordResponse = MysqlChangePasswordResponses[keyof MysqlChangePasswordResponses];
export type MysqlMoveData = {
    body: {
        mysqlId: string;
        targetEnvironmentId: string;
    };
    path?: never;
    query?: never;
    url: "/mysql.move";
};
export type MysqlMoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlMoveError = MysqlMoveErrors[keyof MysqlMoveErrors];
export type MysqlMoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlMoveResponse = MysqlMoveResponses[keyof MysqlMoveResponses];
export type MysqlRebuildData = {
    body: {
        mysqlId: string;
    };
    path?: never;
    query?: never;
    url: "/mysql.rebuild";
};
export type MysqlRebuildErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlRebuildError = MysqlRebuildErrors[keyof MysqlRebuildErrors];
export type MysqlRebuildResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlRebuildResponse = MysqlRebuildResponses[keyof MysqlRebuildResponses];
export type MysqlSearchData = {
    body?: never;
    path?: never;
    query?: {
        q?: string;
        name?: string;
        appName?: string;
        description?: string;
        projectId?: string;
        environmentId?: string;
        limit?: number;
        offset?: number;
    };
    url: "/mysql.search";
};
export type MysqlSearchErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlSearchError = MysqlSearchErrors[keyof MysqlSearchErrors];
export type MysqlSearchResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlSearchResponse = MysqlSearchResponses[keyof MysqlSearchResponses];
export type MysqlReadLogsData = {
    body?: never;
    path?: never;
    query: {
        mysqlId: string;
        tail?: number;
        since?: string;
        search?: string;
    };
    url: "/mysql.readLogs";
};
export type MysqlReadLogsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type MysqlReadLogsError = MysqlReadLogsErrors[keyof MysqlReadLogsErrors];
export type MysqlReadLogsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type MysqlReadLogsResponse = MysqlReadLogsResponses[keyof MysqlReadLogsResponses];
export type NotificationCreateSlackData = {
    body: {
        appBuildError: boolean;
        databaseBackup: boolean;
        dokployBackup: boolean;
        volumeBackup: boolean;
        dokployRestart: boolean;
        name: string;
        appDeploy: boolean;
        dockerCleanup: boolean;
        serverThreshold: boolean;
        webhookUrl: string;
        channel: string;
    };
    path?: never;
    query?: never;
    url: "/notification.createSlack";
};
export type NotificationCreateSlackErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationCreateSlackError = NotificationCreateSlackErrors[keyof NotificationCreateSlackErrors];
export type NotificationCreateSlackResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationCreateSlackResponse = NotificationCreateSlackResponses[keyof NotificationCreateSlackResponses];
export type NotificationUpdateSlackData = {
    body: {
        appBuildError?: boolean;
        databaseBackup?: boolean;
        dokployBackup?: boolean;
        volumeBackup?: boolean;
        dokployRestart?: boolean;
        name?: string;
        appDeploy?: boolean;
        dockerCleanup?: boolean;
        serverThreshold?: boolean;
        webhookUrl?: string;
        channel?: string;
        notificationId: string;
        slackId: string;
        organizationId?: string;
    };
    path?: never;
    query?: never;
    url: "/notification.updateSlack";
};
export type NotificationUpdateSlackErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationUpdateSlackError = NotificationUpdateSlackErrors[keyof NotificationUpdateSlackErrors];
export type NotificationUpdateSlackResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationUpdateSlackResponse = NotificationUpdateSlackResponses[keyof NotificationUpdateSlackResponses];
export type NotificationTestSlackConnectionData = {
    body: {
        webhookUrl: string;
        channel: string;
    };
    path?: never;
    query?: never;
    url: "/notification.testSlackConnection";
};
export type NotificationTestSlackConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationTestSlackConnectionError = NotificationTestSlackConnectionErrors[keyof NotificationTestSlackConnectionErrors];
export type NotificationTestSlackConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationTestSlackConnectionResponse = NotificationTestSlackConnectionResponses[keyof NotificationTestSlackConnectionResponses];
export type NotificationCreateTelegramData = {
    body: {
        appBuildError: boolean;
        databaseBackup: boolean;
        dokployBackup: boolean;
        volumeBackup: boolean;
        dokployRestart: boolean;
        name: string;
        appDeploy: boolean;
        dockerCleanup: boolean;
        serverThreshold: boolean;
        botToken: string;
        chatId: string;
        messageThreadId: string;
    };
    path?: never;
    query?: never;
    url: "/notification.createTelegram";
};
export type NotificationCreateTelegramErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationCreateTelegramError = NotificationCreateTelegramErrors[keyof NotificationCreateTelegramErrors];
export type NotificationCreateTelegramResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationCreateTelegramResponse = NotificationCreateTelegramResponses[keyof NotificationCreateTelegramResponses];
export type NotificationUpdateTelegramData = {
    body: {
        appBuildError?: boolean;
        databaseBackup?: boolean;
        dokployBackup?: boolean;
        volumeBackup?: boolean;
        dokployRestart?: boolean;
        name?: string;
        appDeploy?: boolean;
        dockerCleanup?: boolean;
        serverThreshold?: boolean;
        botToken?: string;
        chatId?: string;
        messageThreadId?: string;
        notificationId: string;
        telegramId: string;
        organizationId?: string;
    };
    path?: never;
    query?: never;
    url: "/notification.updateTelegram";
};
export type NotificationUpdateTelegramErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationUpdateTelegramError = NotificationUpdateTelegramErrors[keyof NotificationUpdateTelegramErrors];
export type NotificationUpdateTelegramResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationUpdateTelegramResponse = NotificationUpdateTelegramResponses[keyof NotificationUpdateTelegramResponses];
export type NotificationTestTelegramConnectionData = {
    body: {
        botToken: string;
        chatId: string;
        messageThreadId: string;
    };
    path?: never;
    query?: never;
    url: "/notification.testTelegramConnection";
};
export type NotificationTestTelegramConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationTestTelegramConnectionError = NotificationTestTelegramConnectionErrors[keyof NotificationTestTelegramConnectionErrors];
export type NotificationTestTelegramConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationTestTelegramConnectionResponse = NotificationTestTelegramConnectionResponses[keyof NotificationTestTelegramConnectionResponses];
export type NotificationCreateDiscordData = {
    body: {
        appBuildError: boolean;
        databaseBackup: boolean;
        dokployBackup: boolean;
        volumeBackup: boolean;
        dokployRestart: boolean;
        name: string;
        appDeploy: boolean;
        dockerCleanup: boolean;
        serverThreshold: boolean;
        webhookUrl: string;
        decoration: boolean;
    };
    path?: never;
    query?: never;
    url: "/notification.createDiscord";
};
export type NotificationCreateDiscordErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationCreateDiscordError = NotificationCreateDiscordErrors[keyof NotificationCreateDiscordErrors];
export type NotificationCreateDiscordResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationCreateDiscordResponse = NotificationCreateDiscordResponses[keyof NotificationCreateDiscordResponses];
export type NotificationUpdateDiscordData = {
    body: {
        appBuildError?: boolean;
        databaseBackup?: boolean;
        dokployBackup?: boolean;
        volumeBackup?: boolean;
        dokployRestart?: boolean;
        name?: string;
        appDeploy?: boolean;
        dockerCleanup?: boolean;
        serverThreshold?: boolean;
        webhookUrl?: string;
        decoration?: boolean;
        notificationId: string;
        discordId: string;
        organizationId?: string;
    };
    path?: never;
    query?: never;
    url: "/notification.updateDiscord";
};
export type NotificationUpdateDiscordErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationUpdateDiscordError = NotificationUpdateDiscordErrors[keyof NotificationUpdateDiscordErrors];
export type NotificationUpdateDiscordResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationUpdateDiscordResponse = NotificationUpdateDiscordResponses[keyof NotificationUpdateDiscordResponses];
export type NotificationTestDiscordConnectionData = {
    body: {
        webhookUrl: string;
        decoration?: boolean;
    };
    path?: never;
    query?: never;
    url: "/notification.testDiscordConnection";
};
export type NotificationTestDiscordConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationTestDiscordConnectionError = NotificationTestDiscordConnectionErrors[keyof NotificationTestDiscordConnectionErrors];
export type NotificationTestDiscordConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationTestDiscordConnectionResponse = NotificationTestDiscordConnectionResponses[keyof NotificationTestDiscordConnectionResponses];
export type NotificationCreateEmailData = {
    body: {
        appBuildError: boolean;
        databaseBackup: boolean;
        dokployBackup: boolean;
        volumeBackup: boolean;
        dokployRestart: boolean;
        name: string;
        appDeploy: boolean;
        dockerCleanup: boolean;
        serverThreshold: boolean;
        smtpServer: string;
        smtpPort: number;
        username: string;
        password: string;
        fromAddress: string;
        toAddresses: Array<string>;
    };
    path?: never;
    query?: never;
    url: "/notification.createEmail";
};
export type NotificationCreateEmailErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationCreateEmailError = NotificationCreateEmailErrors[keyof NotificationCreateEmailErrors];
export type NotificationCreateEmailResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationCreateEmailResponse = NotificationCreateEmailResponses[keyof NotificationCreateEmailResponses];
export type NotificationUpdateEmailData = {
    body: {
        appBuildError?: boolean;
        databaseBackup?: boolean;
        dokployBackup?: boolean;
        volumeBackup?: boolean;
        dokployRestart?: boolean;
        name?: string;
        appDeploy?: boolean;
        dockerCleanup?: boolean;
        serverThreshold?: boolean;
        smtpServer?: string;
        smtpPort?: number;
        username?: string;
        password?: string;
        fromAddress?: string;
        toAddresses?: Array<string>;
        notificationId: string;
        emailId: string;
        organizationId?: string;
    };
    path?: never;
    query?: never;
    url: "/notification.updateEmail";
};
export type NotificationUpdateEmailErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationUpdateEmailError = NotificationUpdateEmailErrors[keyof NotificationUpdateEmailErrors];
export type NotificationUpdateEmailResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationUpdateEmailResponse = NotificationUpdateEmailResponses[keyof NotificationUpdateEmailResponses];
export type NotificationTestEmailConnectionData = {
    body: {
        smtpServer: string;
        smtpPort: number;
        username: string;
        password: string;
        toAddresses: Array<string>;
        fromAddress: string;
    };
    path?: never;
    query?: never;
    url: "/notification.testEmailConnection";
};
export type NotificationTestEmailConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationTestEmailConnectionError = NotificationTestEmailConnectionErrors[keyof NotificationTestEmailConnectionErrors];
export type NotificationTestEmailConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationTestEmailConnectionResponse = NotificationTestEmailConnectionResponses[keyof NotificationTestEmailConnectionResponses];
export type NotificationCreateResendData = {
    body: {
        appBuildError: boolean;
        databaseBackup: boolean;
        dokployBackup: boolean;
        volumeBackup: boolean;
        dokployRestart: boolean;
        name: string;
        appDeploy: boolean;
        dockerCleanup: boolean;
        serverThreshold: boolean;
        apiKey: string;
        fromAddress: string;
        toAddresses: Array<string>;
    };
    path?: never;
    query?: never;
    url: "/notification.createResend";
};
export type NotificationCreateResendErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationCreateResendError = NotificationCreateResendErrors[keyof NotificationCreateResendErrors];
export type NotificationCreateResendResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationCreateResendResponse = NotificationCreateResendResponses[keyof NotificationCreateResendResponses];
export type NotificationUpdateResendData = {
    body: {
        appBuildError?: boolean;
        databaseBackup?: boolean;
        dokployBackup?: boolean;
        volumeBackup?: boolean;
        dokployRestart?: boolean;
        name?: string;
        appDeploy?: boolean;
        dockerCleanup?: boolean;
        serverThreshold?: boolean;
        apiKey?: string;
        fromAddress?: string;
        toAddresses?: Array<string>;
        notificationId: string;
        resendId: string;
        organizationId?: string;
    };
    path?: never;
    query?: never;
    url: "/notification.updateResend";
};
export type NotificationUpdateResendErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationUpdateResendError = NotificationUpdateResendErrors[keyof NotificationUpdateResendErrors];
export type NotificationUpdateResendResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationUpdateResendResponse = NotificationUpdateResendResponses[keyof NotificationUpdateResendResponses];
export type NotificationTestResendConnectionData = {
    body: {
        apiKey: string;
        fromAddress: string;
        toAddresses: Array<string>;
    };
    path?: never;
    query?: never;
    url: "/notification.testResendConnection";
};
export type NotificationTestResendConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationTestResendConnectionError = NotificationTestResendConnectionErrors[keyof NotificationTestResendConnectionErrors];
export type NotificationTestResendConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationTestResendConnectionResponse = NotificationTestResendConnectionResponses[keyof NotificationTestResendConnectionResponses];
export type NotificationRemoveData = {
    body: {
        notificationId: string;
    };
    path?: never;
    query?: never;
    url: "/notification.remove";
};
export type NotificationRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationRemoveError = NotificationRemoveErrors[keyof NotificationRemoveErrors];
export type NotificationRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationRemoveResponse = NotificationRemoveResponses[keyof NotificationRemoveResponses];
export type NotificationOneData = {
    body?: never;
    path?: never;
    query: {
        notificationId: string;
    };
    url: "/notification.one";
};
export type NotificationOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationOneError = NotificationOneErrors[keyof NotificationOneErrors];
export type NotificationOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationOneResponse = NotificationOneResponses[keyof NotificationOneResponses];
export type NotificationAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/notification.all";
};
export type NotificationAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationAllError = NotificationAllErrors[keyof NotificationAllErrors];
export type NotificationAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationAllResponse = NotificationAllResponses[keyof NotificationAllResponses];
export type NotificationReceiveNotificationData = {
    body: {
        ServerType?: "Dokploy" | "Remote";
        Type: "Memory" | "CPU";
        Value: number;
        Threshold: number;
        Message: string;
        Timestamp: string;
        Token: string;
    };
    path?: never;
    query?: never;
    url: "/notification.receiveNotification";
};
export type NotificationReceiveNotificationErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationReceiveNotificationError = NotificationReceiveNotificationErrors[keyof NotificationReceiveNotificationErrors];
export type NotificationReceiveNotificationResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationReceiveNotificationResponse = NotificationReceiveNotificationResponses[keyof NotificationReceiveNotificationResponses];
export type NotificationCreateGotifyData = {
    body: {
        appBuildError: boolean;
        databaseBackup: boolean;
        dokployBackup: boolean;
        volumeBackup: boolean;
        dokployRestart: boolean;
        name: string;
        appDeploy: boolean;
        dockerCleanup: boolean;
        serverThreshold: boolean;
        serverUrl: string;
        appToken: string;
        priority: number;
        decoration: boolean;
    };
    path?: never;
    query?: never;
    url: "/notification.createGotify";
};
export type NotificationCreateGotifyErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationCreateGotifyError = NotificationCreateGotifyErrors[keyof NotificationCreateGotifyErrors];
export type NotificationCreateGotifyResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationCreateGotifyResponse = NotificationCreateGotifyResponses[keyof NotificationCreateGotifyResponses];
export type NotificationUpdateGotifyData = {
    body: {
        appBuildError?: boolean;
        databaseBackup?: boolean;
        dokployBackup?: boolean;
        volumeBackup?: boolean;
        dokployRestart?: boolean;
        name?: string;
        appDeploy?: boolean;
        dockerCleanup?: boolean;
        serverThreshold?: boolean;
        serverUrl?: string;
        appToken?: string;
        priority?: number;
        decoration?: boolean;
        notificationId: string;
        gotifyId: string;
        organizationId?: string;
    };
    path?: never;
    query?: never;
    url: "/notification.updateGotify";
};
export type NotificationUpdateGotifyErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationUpdateGotifyError = NotificationUpdateGotifyErrors[keyof NotificationUpdateGotifyErrors];
export type NotificationUpdateGotifyResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationUpdateGotifyResponse = NotificationUpdateGotifyResponses[keyof NotificationUpdateGotifyResponses];
export type NotificationTestGotifyConnectionData = {
    body: {
        serverUrl: string;
        appToken: string;
        priority: number;
        decoration?: boolean;
    };
    path?: never;
    query?: never;
    url: "/notification.testGotifyConnection";
};
export type NotificationTestGotifyConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationTestGotifyConnectionError = NotificationTestGotifyConnectionErrors[keyof NotificationTestGotifyConnectionErrors];
export type NotificationTestGotifyConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationTestGotifyConnectionResponse = NotificationTestGotifyConnectionResponses[keyof NotificationTestGotifyConnectionResponses];
export type NotificationCreateNtfyData = {
    body: {
        appBuildError: boolean;
        databaseBackup: boolean;
        dokployBackup: boolean;
        volumeBackup: boolean;
        dokployRestart: boolean;
        name: string;
        appDeploy: boolean;
        dockerCleanup: boolean;
        serverThreshold: boolean;
        serverUrl: string;
        topic: string;
        accessToken: string;
        priority: number;
    };
    path?: never;
    query?: never;
    url: "/notification.createNtfy";
};
export type NotificationCreateNtfyErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationCreateNtfyError = NotificationCreateNtfyErrors[keyof NotificationCreateNtfyErrors];
export type NotificationCreateNtfyResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationCreateNtfyResponse = NotificationCreateNtfyResponses[keyof NotificationCreateNtfyResponses];
export type NotificationUpdateNtfyData = {
    body: {
        appBuildError?: boolean;
        databaseBackup?: boolean;
        dokployBackup?: boolean;
        volumeBackup?: boolean;
        dokployRestart?: boolean;
        name?: string;
        appDeploy?: boolean;
        dockerCleanup?: boolean;
        serverThreshold?: boolean;
        serverUrl?: string;
        topic?: string;
        accessToken?: string;
        priority?: number;
        notificationId: string;
        ntfyId: string;
        organizationId?: string;
    };
    path?: never;
    query?: never;
    url: "/notification.updateNtfy";
};
export type NotificationUpdateNtfyErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationUpdateNtfyError = NotificationUpdateNtfyErrors[keyof NotificationUpdateNtfyErrors];
export type NotificationUpdateNtfyResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationUpdateNtfyResponse = NotificationUpdateNtfyResponses[keyof NotificationUpdateNtfyResponses];
export type NotificationTestNtfyConnectionData = {
    body: {
        serverUrl: string;
        topic: string;
        accessToken: string;
        priority: number;
    };
    path?: never;
    query?: never;
    url: "/notification.testNtfyConnection";
};
export type NotificationTestNtfyConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationTestNtfyConnectionError = NotificationTestNtfyConnectionErrors[keyof NotificationTestNtfyConnectionErrors];
export type NotificationTestNtfyConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationTestNtfyConnectionResponse = NotificationTestNtfyConnectionResponses[keyof NotificationTestNtfyConnectionResponses];
export type NotificationCreateMattermostData = {
    body: {
        appBuildError: boolean;
        databaseBackup: boolean;
        dokployBackup: boolean;
        volumeBackup: boolean;
        dokployRestart: boolean;
        name: string;
        appDeploy: boolean;
        dockerCleanup: boolean;
        serverThreshold: boolean;
        webhookUrl: string;
        channel?: string;
        username?: string;
    };
    path?: never;
    query?: never;
    url: "/notification.createMattermost";
};
export type NotificationCreateMattermostErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationCreateMattermostError = NotificationCreateMattermostErrors[keyof NotificationCreateMattermostErrors];
export type NotificationCreateMattermostResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationCreateMattermostResponse = NotificationCreateMattermostResponses[keyof NotificationCreateMattermostResponses];
export type NotificationUpdateMattermostData = {
    body: {
        appBuildError?: boolean;
        databaseBackup?: boolean;
        dokployBackup?: boolean;
        volumeBackup?: boolean;
        dokployRestart?: boolean;
        name?: string;
        appDeploy?: boolean;
        dockerCleanup?: boolean;
        serverThreshold?: boolean;
        webhookUrl?: string;
        channel?: string;
        username?: string;
        notificationId: string;
        mattermostId: string;
        organizationId?: string;
    };
    path?: never;
    query?: never;
    url: "/notification.updateMattermost";
};
export type NotificationUpdateMattermostErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationUpdateMattermostError = NotificationUpdateMattermostErrors[keyof NotificationUpdateMattermostErrors];
export type NotificationUpdateMattermostResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationUpdateMattermostResponse = NotificationUpdateMattermostResponses[keyof NotificationUpdateMattermostResponses];
export type NotificationTestMattermostConnectionData = {
    body: {
        webhookUrl: string;
        channel?: string;
        username?: string;
    };
    path?: never;
    query?: never;
    url: "/notification.testMattermostConnection";
};
export type NotificationTestMattermostConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationTestMattermostConnectionError = NotificationTestMattermostConnectionErrors[keyof NotificationTestMattermostConnectionErrors];
export type NotificationTestMattermostConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationTestMattermostConnectionResponse = NotificationTestMattermostConnectionResponses[keyof NotificationTestMattermostConnectionResponses];
export type NotificationCreateCustomData = {
    body: {
        appBuildError?: boolean;
        databaseBackup?: boolean;
        dokployBackup?: boolean;
        volumeBackup?: boolean;
        dokployRestart?: boolean;
        name: string;
        appDeploy?: boolean;
        dockerCleanup?: boolean;
        serverThreshold?: boolean;
        endpoint: string;
        headers?: {
            [key: string]: string;
        };
    };
    path?: never;
    query?: never;
    url: "/notification.createCustom";
};
export type NotificationCreateCustomErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationCreateCustomError = NotificationCreateCustomErrors[keyof NotificationCreateCustomErrors];
export type NotificationCreateCustomResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationCreateCustomResponse = NotificationCreateCustomResponses[keyof NotificationCreateCustomResponses];
export type NotificationUpdateCustomData = {
    body: {
        appBuildError?: boolean;
        databaseBackup?: boolean;
        dokployBackup?: boolean;
        volumeBackup?: boolean;
        dokployRestart?: boolean;
        name?: string;
        appDeploy?: boolean;
        dockerCleanup?: boolean;
        serverThreshold?: boolean;
        endpoint?: string;
        headers?: {
            [key: string]: string;
        };
        notificationId: string;
        customId: string;
        organizationId?: string;
    };
    path?: never;
    query?: never;
    url: "/notification.updateCustom";
};
export type NotificationUpdateCustomErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationUpdateCustomError = NotificationUpdateCustomErrors[keyof NotificationUpdateCustomErrors];
export type NotificationUpdateCustomResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationUpdateCustomResponse = NotificationUpdateCustomResponses[keyof NotificationUpdateCustomResponses];
export type NotificationTestCustomConnectionData = {
    body: {
        endpoint: string;
        headers?: {
            [key: string]: string;
        };
    };
    path?: never;
    query?: never;
    url: "/notification.testCustomConnection";
};
export type NotificationTestCustomConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationTestCustomConnectionError = NotificationTestCustomConnectionErrors[keyof NotificationTestCustomConnectionErrors];
export type NotificationTestCustomConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationTestCustomConnectionResponse = NotificationTestCustomConnectionResponses[keyof NotificationTestCustomConnectionResponses];
export type NotificationCreateLarkData = {
    body: {
        appBuildError: boolean;
        databaseBackup: boolean;
        dokployBackup: boolean;
        volumeBackup: boolean;
        dokployRestart: boolean;
        name: string;
        appDeploy: boolean;
        dockerCleanup: boolean;
        serverThreshold: boolean;
        webhookUrl: string;
    };
    path?: never;
    query?: never;
    url: "/notification.createLark";
};
export type NotificationCreateLarkErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationCreateLarkError = NotificationCreateLarkErrors[keyof NotificationCreateLarkErrors];
export type NotificationCreateLarkResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationCreateLarkResponse = NotificationCreateLarkResponses[keyof NotificationCreateLarkResponses];
export type NotificationUpdateLarkData = {
    body: {
        appBuildError?: boolean;
        databaseBackup?: boolean;
        dokployBackup?: boolean;
        volumeBackup?: boolean;
        dokployRestart?: boolean;
        name?: string;
        appDeploy?: boolean;
        dockerCleanup?: boolean;
        serverThreshold?: boolean;
        webhookUrl?: string;
        notificationId: string;
        larkId: string;
        organizationId?: string;
    };
    path?: never;
    query?: never;
    url: "/notification.updateLark";
};
export type NotificationUpdateLarkErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationUpdateLarkError = NotificationUpdateLarkErrors[keyof NotificationUpdateLarkErrors];
export type NotificationUpdateLarkResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationUpdateLarkResponse = NotificationUpdateLarkResponses[keyof NotificationUpdateLarkResponses];
export type NotificationTestLarkConnectionData = {
    body: {
        webhookUrl: string;
    };
    path?: never;
    query?: never;
    url: "/notification.testLarkConnection";
};
export type NotificationTestLarkConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationTestLarkConnectionError = NotificationTestLarkConnectionErrors[keyof NotificationTestLarkConnectionErrors];
export type NotificationTestLarkConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationTestLarkConnectionResponse = NotificationTestLarkConnectionResponses[keyof NotificationTestLarkConnectionResponses];
export type NotificationCreateTeamsData = {
    body: {
        appBuildError: boolean;
        databaseBackup: boolean;
        dokployBackup: boolean;
        volumeBackup: boolean;
        dokployRestart: boolean;
        name: string;
        appDeploy: boolean;
        dockerCleanup: boolean;
        serverThreshold: boolean;
        webhookUrl: string;
    };
    path?: never;
    query?: never;
    url: "/notification.createTeams";
};
export type NotificationCreateTeamsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationCreateTeamsError = NotificationCreateTeamsErrors[keyof NotificationCreateTeamsErrors];
export type NotificationCreateTeamsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationCreateTeamsResponse = NotificationCreateTeamsResponses[keyof NotificationCreateTeamsResponses];
export type NotificationUpdateTeamsData = {
    body: {
        appBuildError?: boolean;
        databaseBackup?: boolean;
        dokployBackup?: boolean;
        volumeBackup?: boolean;
        dokployRestart?: boolean;
        name?: string;
        appDeploy?: boolean;
        dockerCleanup?: boolean;
        serverThreshold?: boolean;
        webhookUrl?: string;
        notificationId: string;
        teamsId: string;
        organizationId?: string;
    };
    path?: never;
    query?: never;
    url: "/notification.updateTeams";
};
export type NotificationUpdateTeamsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationUpdateTeamsError = NotificationUpdateTeamsErrors[keyof NotificationUpdateTeamsErrors];
export type NotificationUpdateTeamsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationUpdateTeamsResponse = NotificationUpdateTeamsResponses[keyof NotificationUpdateTeamsResponses];
export type NotificationTestTeamsConnectionData = {
    body: {
        webhookUrl: string;
    };
    path?: never;
    query?: never;
    url: "/notification.testTeamsConnection";
};
export type NotificationTestTeamsConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationTestTeamsConnectionError = NotificationTestTeamsConnectionErrors[keyof NotificationTestTeamsConnectionErrors];
export type NotificationTestTeamsConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationTestTeamsConnectionResponse = NotificationTestTeamsConnectionResponses[keyof NotificationTestTeamsConnectionResponses];
export type NotificationCreatePushoverData = {
    body: {
        appBuildError?: boolean;
        databaseBackup?: boolean;
        dokployBackup?: boolean;
        volumeBackup?: boolean;
        dokployRestart?: boolean;
        name: string;
        appDeploy?: boolean;
        dockerCleanup?: boolean;
        serverThreshold?: boolean;
        userKey: string;
        apiToken: string;
        priority?: number;
        retry?: number | null;
        expire?: number | null;
    };
    path?: never;
    query?: never;
    url: "/notification.createPushover";
};
export type NotificationCreatePushoverErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationCreatePushoverError = NotificationCreatePushoverErrors[keyof NotificationCreatePushoverErrors];
export type NotificationCreatePushoverResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationCreatePushoverResponse = NotificationCreatePushoverResponses[keyof NotificationCreatePushoverResponses];
export type NotificationUpdatePushoverData = {
    body: {
        notificationId: string;
        pushoverId: string;
        organizationId?: string;
        userKey?: string;
        apiToken?: string;
        priority?: number;
        retry?: number | null;
        expire?: number | null;
        appBuildError?: boolean;
        databaseBackup?: boolean;
        dokployBackup?: boolean;
        volumeBackup?: boolean;
        dokployRestart?: boolean;
        name?: string;
        appDeploy?: boolean;
        dockerCleanup?: boolean;
        serverThreshold?: boolean;
    };
    path?: never;
    query?: never;
    url: "/notification.updatePushover";
};
export type NotificationUpdatePushoverErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationUpdatePushoverError = NotificationUpdatePushoverErrors[keyof NotificationUpdatePushoverErrors];
export type NotificationUpdatePushoverResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationUpdatePushoverResponse = NotificationUpdatePushoverResponses[keyof NotificationUpdatePushoverResponses];
export type NotificationTestPushoverConnectionData = {
    body: {
        userKey: string;
        apiToken: string;
        priority: number;
        retry?: number | null;
        expire?: number | null;
    };
    path?: never;
    query?: never;
    url: "/notification.testPushoverConnection";
};
export type NotificationTestPushoverConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationTestPushoverConnectionError = NotificationTestPushoverConnectionErrors[keyof NotificationTestPushoverConnectionErrors];
export type NotificationTestPushoverConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationTestPushoverConnectionResponse = NotificationTestPushoverConnectionResponses[keyof NotificationTestPushoverConnectionResponses];
export type NotificationGetEmailProvidersData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/notification.getEmailProviders";
};
export type NotificationGetEmailProvidersErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type NotificationGetEmailProvidersError = NotificationGetEmailProvidersErrors[keyof NotificationGetEmailProvidersErrors];
export type NotificationGetEmailProvidersResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type NotificationGetEmailProvidersResponse = NotificationGetEmailProvidersResponses[keyof NotificationGetEmailProvidersResponses];
export type PortCreateData = {
    body: {
        publishedPort: number;
        publishMode: "ingress" | "host";
        targetPort: number;
        protocol: "tcp" | "udp";
        applicationId: string;
    };
    path?: never;
    query?: never;
    url: "/port.create";
};
export type PortCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PortCreateError = PortCreateErrors[keyof PortCreateErrors];
export type PortCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PortCreateResponse = PortCreateResponses[keyof PortCreateResponses];
export type PortOneData = {
    body?: never;
    path?: never;
    query: {
        portId: string;
    };
    url: "/port.one";
};
export type PortOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PortOneError = PortOneErrors[keyof PortOneErrors];
export type PortOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PortOneResponse = PortOneResponses[keyof PortOneResponses];
export type PortDeleteData = {
    body: {
        portId: string;
    };
    path?: never;
    query?: never;
    url: "/port.delete";
};
export type PortDeleteErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PortDeleteError = PortDeleteErrors[keyof PortDeleteErrors];
export type PortDeleteResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PortDeleteResponse = PortDeleteResponses[keyof PortDeleteResponses];
export type PortUpdateData = {
    body: {
        portId: string;
        publishedPort: number;
        publishMode: "ingress" | "host";
        targetPort: number;
        protocol: "tcp" | "udp";
    };
    path?: never;
    query?: never;
    url: "/port.update";
};
export type PortUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PortUpdateError = PortUpdateErrors[keyof PortUpdateErrors];
export type PortUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PortUpdateResponse = PortUpdateResponses[keyof PortUpdateResponses];
export type PostgresCreateData = {
    body: {
        name: string;
        appName?: string;
        databaseName: string;
        databaseUser: string;
        databasePassword: string;
        dockerImage?: string;
        environmentId: string;
        description?: string | null;
        serverId?: string | null;
    };
    path?: never;
    query?: never;
    url: "/postgres.create";
};
export type PostgresCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresCreateError = PostgresCreateErrors[keyof PostgresCreateErrors];
export type PostgresCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresCreateResponse = PostgresCreateResponses[keyof PostgresCreateResponses];
export type PostgresOneData = {
    body?: never;
    path?: never;
    query: {
        postgresId: string;
    };
    url: "/postgres.one";
};
export type PostgresOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresOneError = PostgresOneErrors[keyof PostgresOneErrors];
export type PostgresOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresOneResponse = PostgresOneResponses[keyof PostgresOneResponses];
export type PostgresStartData = {
    body: {
        postgresId: string;
    };
    path?: never;
    query?: never;
    url: "/postgres.start";
};
export type PostgresStartErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresStartError = PostgresStartErrors[keyof PostgresStartErrors];
export type PostgresStartResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresStartResponse = PostgresStartResponses[keyof PostgresStartResponses];
export type PostgresStopData = {
    body: {
        postgresId: string;
    };
    path?: never;
    query?: never;
    url: "/postgres.stop";
};
export type PostgresStopErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresStopError = PostgresStopErrors[keyof PostgresStopErrors];
export type PostgresStopResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresStopResponse = PostgresStopResponses[keyof PostgresStopResponses];
export type PostgresSaveExternalPortData = {
    body: {
        postgresId: string;
        externalPort: number | null;
    };
    path?: never;
    query?: never;
    url: "/postgres.saveExternalPort";
};
export type PostgresSaveExternalPortErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresSaveExternalPortError = PostgresSaveExternalPortErrors[keyof PostgresSaveExternalPortErrors];
export type PostgresSaveExternalPortResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresSaveExternalPortResponse = PostgresSaveExternalPortResponses[keyof PostgresSaveExternalPortResponses];
export type PostgresDeployData = {
    body: {
        postgresId: string;
    };
    path?: never;
    query?: never;
    url: "/postgres.deploy";
};
export type PostgresDeployErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresDeployError = PostgresDeployErrors[keyof PostgresDeployErrors];
export type PostgresDeployResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresDeployResponse = PostgresDeployResponses[keyof PostgresDeployResponses];
export type PostgresChangeStatusData = {
    body: {
        postgresId: string;
        applicationStatus: "idle" | "running" | "done" | "error";
    };
    path?: never;
    query?: never;
    url: "/postgres.changeStatus";
};
export type PostgresChangeStatusErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresChangeStatusError = PostgresChangeStatusErrors[keyof PostgresChangeStatusErrors];
export type PostgresChangeStatusResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresChangeStatusResponse = PostgresChangeStatusResponses[keyof PostgresChangeStatusResponses];
export type PostgresRemoveData = {
    body: {
        postgresId: string;
    };
    path?: never;
    query?: never;
    url: "/postgres.remove";
};
export type PostgresRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresRemoveError = PostgresRemoveErrors[keyof PostgresRemoveErrors];
export type PostgresRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresRemoveResponse = PostgresRemoveResponses[keyof PostgresRemoveResponses];
export type PostgresSaveEnvironmentData = {
    body: {
        postgresId: string;
        env: string | null;
    };
    path?: never;
    query?: never;
    url: "/postgres.saveEnvironment";
};
export type PostgresSaveEnvironmentErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresSaveEnvironmentError = PostgresSaveEnvironmentErrors[keyof PostgresSaveEnvironmentErrors];
export type PostgresSaveEnvironmentResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresSaveEnvironmentResponse = PostgresSaveEnvironmentResponses[keyof PostgresSaveEnvironmentResponses];
export type PostgresReloadData = {
    body: {
        postgresId: string;
        appName: string;
    };
    path?: never;
    query?: never;
    url: "/postgres.reload";
};
export type PostgresReloadErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresReloadError = PostgresReloadErrors[keyof PostgresReloadErrors];
export type PostgresReloadResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresReloadResponse = PostgresReloadResponses[keyof PostgresReloadResponses];
export type PostgresUpdateData = {
    body: {
        postgresId: string;
        name?: string;
        appName?: string;
        databaseName?: string;
        databaseUser?: string;
        databasePassword?: string;
        description?: string | null;
        dockerImage?: string;
        command?: string | null;
        args?: Array<string> | null;
        env?: string | null;
        memoryReservation?: string | null;
        externalPort?: number | null;
        memoryLimit?: string | null;
        cpuReservation?: string | null;
        cpuLimit?: string | null;
        applicationStatus?: "idle" | "running" | "done" | "error";
        healthCheckSwarm?: {
            Test?: Array<string>;
            Interval?: number;
            Timeout?: number;
            StartPeriod?: number;
            Retries?: number;
        } | null | null;
        restartPolicySwarm?: {
            Condition?: string;
            Delay?: number;
            MaxAttempts?: number;
            Window?: number;
        } | null | null;
        placementSwarm?: {
            Constraints?: Array<string>;
            Preferences?: Array<{
                Spread: {
                    SpreadDescriptor: string;
                };
            }>;
            MaxReplicas?: number;
            Platforms?: Array<{
                Architecture: string;
                OS: string;
            }>;
        } | null | null;
        updateConfigSwarm?: {
            Parallelism: number;
            Delay?: number;
            FailureAction?: string;
            Monitor?: number;
            MaxFailureRatio?: number;
            Order: string;
        } | null | null;
        rollbackConfigSwarm?: {
            Parallelism: number;
            Delay?: number;
            FailureAction?: string;
            Monitor?: number;
            MaxFailureRatio?: number;
            Order: string;
        } | null | null;
        modeSwarm?: {
            Replicated?: {
                Replicas?: number;
            };
            Global?: {
                [key: string]: unknown;
            };
            ReplicatedJob?: {
                MaxConcurrent?: number;
                TotalCompletions?: number;
            };
            GlobalJob?: {
                [key: string]: unknown;
            };
        } | null | null;
        labelsSwarm?: {
            [key: string]: string;
        } | null | null;
        networkSwarm?: Array<{
            Target?: string;
            Aliases?: Array<string>;
            DriverOpts?: {
                [key: string]: string;
            };
        }> | null | null;
        stopGracePeriodSwarm?: number | null | null;
        endpointSpecSwarm?: {
            Mode?: string;
            Ports?: Array<{
                Protocol?: string;
                TargetPort?: number;
                PublishedPort?: number;
                PublishMode?: string;
            }>;
        } | null | null;
        ulimitsSwarm?: Array<{
            Name: string;
            Soft: number;
            Hard: number;
        }> | null | null;
        replicas?: number;
        createdAt?: string;
        environmentId?: string;
        networkIds?: Array<string> | null;
        detachDokployNetwork?: boolean;
    };
    path?: never;
    query?: never;
    url: "/postgres.update";
};
export type PostgresUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresUpdateError = PostgresUpdateErrors[keyof PostgresUpdateErrors];
export type PostgresUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresUpdateResponse = PostgresUpdateResponses[keyof PostgresUpdateResponses];
export type PostgresChangePasswordData = {
    body: {
        postgresId: string;
        password: string;
    };
    path?: never;
    query?: never;
    url: "/postgres.changePassword";
};
export type PostgresChangePasswordErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresChangePasswordError = PostgresChangePasswordErrors[keyof PostgresChangePasswordErrors];
export type PostgresChangePasswordResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresChangePasswordResponse = PostgresChangePasswordResponses[keyof PostgresChangePasswordResponses];
export type PostgresMoveData = {
    body: {
        postgresId: string;
        targetEnvironmentId: string;
    };
    path?: never;
    query?: never;
    url: "/postgres.move";
};
export type PostgresMoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresMoveError = PostgresMoveErrors[keyof PostgresMoveErrors];
export type PostgresMoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresMoveResponse = PostgresMoveResponses[keyof PostgresMoveResponses];
export type PostgresRebuildData = {
    body: {
        postgresId: string;
    };
    path?: never;
    query?: never;
    url: "/postgres.rebuild";
};
export type PostgresRebuildErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresRebuildError = PostgresRebuildErrors[keyof PostgresRebuildErrors];
export type PostgresRebuildResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresRebuildResponse = PostgresRebuildResponses[keyof PostgresRebuildResponses];
export type PostgresSearchData = {
    body?: never;
    path?: never;
    query?: {
        q?: string;
        name?: string;
        appName?: string;
        description?: string;
        projectId?: string;
        environmentId?: string;
        limit?: number;
        offset?: number;
    };
    url: "/postgres.search";
};
export type PostgresSearchErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresSearchError = PostgresSearchErrors[keyof PostgresSearchErrors];
export type PostgresSearchResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresSearchResponse = PostgresSearchResponses[keyof PostgresSearchResponses];
export type PostgresReadLogsData = {
    body?: never;
    path?: never;
    query: {
        postgresId: string;
        tail?: number;
        since?: string;
        search?: string;
    };
    url: "/postgres.readLogs";
};
export type PostgresReadLogsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PostgresReadLogsError = PostgresReadLogsErrors[keyof PostgresReadLogsErrors];
export type PostgresReadLogsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PostgresReadLogsResponse = PostgresReadLogsResponses[keyof PostgresReadLogsResponses];
export type PreviewDeploymentAllData = {
    body?: never;
    path?: never;
    query: {
        applicationId: string;
    };
    url: "/previewDeployment.all";
};
export type PreviewDeploymentAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PreviewDeploymentAllError = PreviewDeploymentAllErrors[keyof PreviewDeploymentAllErrors];
export type PreviewDeploymentAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PreviewDeploymentAllResponse = PreviewDeploymentAllResponses[keyof PreviewDeploymentAllResponses];
export type PreviewDeploymentOneData = {
    body?: never;
    path?: never;
    query: {
        previewDeploymentId: string;
    };
    url: "/previewDeployment.one";
};
export type PreviewDeploymentOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PreviewDeploymentOneError = PreviewDeploymentOneErrors[keyof PreviewDeploymentOneErrors];
export type PreviewDeploymentOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PreviewDeploymentOneResponse = PreviewDeploymentOneResponses[keyof PreviewDeploymentOneResponses];
export type PreviewDeploymentDeleteData = {
    body: {
        previewDeploymentId: string;
    };
    path?: never;
    query?: never;
    url: "/previewDeployment.delete";
};
export type PreviewDeploymentDeleteErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PreviewDeploymentDeleteError = PreviewDeploymentDeleteErrors[keyof PreviewDeploymentDeleteErrors];
export type PreviewDeploymentDeleteResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PreviewDeploymentDeleteResponse = PreviewDeploymentDeleteResponses[keyof PreviewDeploymentDeleteResponses];
export type PreviewDeploymentRedeployData = {
    body: {
        previewDeploymentId: string;
        title?: string;
        description?: string;
    };
    path?: never;
    query?: never;
    url: "/previewDeployment.redeploy";
};
export type PreviewDeploymentRedeployErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PreviewDeploymentRedeployError = PreviewDeploymentRedeployErrors[keyof PreviewDeploymentRedeployErrors];
export type PreviewDeploymentRedeployResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PreviewDeploymentRedeployResponse = PreviewDeploymentRedeployResponses[keyof PreviewDeploymentRedeployResponses];
export type ProjectCreateData = {
    body: {
        name: string;
        description?: string | null;
        env?: string;
    };
    path?: never;
    query?: never;
    url: "/project.create";
};
export type ProjectCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ProjectCreateError = ProjectCreateErrors[keyof ProjectCreateErrors];
export type ProjectCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ProjectCreateResponse = ProjectCreateResponses[keyof ProjectCreateResponses];
export type ProjectOneData = {
    body?: never;
    path?: never;
    query: {
        projectId: string;
    };
    url: "/project.one";
};
export type ProjectOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ProjectOneError = ProjectOneErrors[keyof ProjectOneErrors];
export type ProjectOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ProjectOneResponse = ProjectOneResponses[keyof ProjectOneResponses];
export type ProjectAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/project.all";
};
export type ProjectAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ProjectAllError = ProjectAllErrors[keyof ProjectAllErrors];
export type ProjectAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ProjectAllResponse = ProjectAllResponses[keyof ProjectAllResponses];
export type ProjectAllForPermissionsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/project.allForPermissions";
};
export type ProjectAllForPermissionsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ProjectAllForPermissionsError = ProjectAllForPermissionsErrors[keyof ProjectAllForPermissionsErrors];
export type ProjectAllForPermissionsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ProjectAllForPermissionsResponse = ProjectAllForPermissionsResponses[keyof ProjectAllForPermissionsResponses];
export type ProjectHomeStatsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/project.homeStats";
};
export type ProjectHomeStatsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ProjectHomeStatsError = ProjectHomeStatsErrors[keyof ProjectHomeStatsErrors];
export type ProjectHomeStatsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ProjectHomeStatsResponse = ProjectHomeStatsResponses[keyof ProjectHomeStatsResponses];
export type ProjectOnboardingStatusData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/project.onboardingStatus";
};
export type ProjectOnboardingStatusErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ProjectOnboardingStatusError = ProjectOnboardingStatusErrors[keyof ProjectOnboardingStatusErrors];
export type ProjectOnboardingStatusResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ProjectOnboardingStatusResponse = ProjectOnboardingStatusResponses[keyof ProjectOnboardingStatusResponses];
export type ProjectCompleteOnboardingData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/project.completeOnboarding";
};
export type ProjectCompleteOnboardingErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ProjectCompleteOnboardingError = ProjectCompleteOnboardingErrors[keyof ProjectCompleteOnboardingErrors];
export type ProjectCompleteOnboardingResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ProjectCompleteOnboardingResponse = ProjectCompleteOnboardingResponses[keyof ProjectCompleteOnboardingResponses];
export type ProjectSearchData = {
    body?: never;
    path?: never;
    query?: {
        q?: string;
        name?: string;
        description?: string;
        limit?: number;
        offset?: number;
    };
    url: "/project.search";
};
export type ProjectSearchErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ProjectSearchError = ProjectSearchErrors[keyof ProjectSearchErrors];
export type ProjectSearchResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ProjectSearchResponse = ProjectSearchResponses[keyof ProjectSearchResponses];
export type ProjectRemoveData = {
    body: {
        projectId: string;
    };
    path?: never;
    query?: never;
    url: "/project.remove";
};
export type ProjectRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ProjectRemoveError = ProjectRemoveErrors[keyof ProjectRemoveErrors];
export type ProjectRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ProjectRemoveResponse = ProjectRemoveResponses[keyof ProjectRemoveResponses];
export type ProjectUpdateData = {
    body: {
        projectId: string;
        name?: string;
        description?: string | null;
        createdAt?: string;
        organizationId?: string;
        env?: string;
    };
    path?: never;
    query?: never;
    url: "/project.update";
};
export type ProjectUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ProjectUpdateError = ProjectUpdateErrors[keyof ProjectUpdateErrors];
export type ProjectUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ProjectUpdateResponse = ProjectUpdateResponses[keyof ProjectUpdateResponses];
export type ProjectDuplicateData = {
    body: {
        sourceEnvironmentId: string;
        name: string;
        description?: string;
        includeServices?: boolean;
        selectedServices?: Array<{
            id: string;
            type: "application" | "compose" | "libsql" | "mariadb" | "mongo" | "mysql" | "postgres" | "redis";
        }>;
        duplicateInSameProject?: boolean;
    };
    path?: never;
    query?: never;
    url: "/project.duplicate";
};
export type ProjectDuplicateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ProjectDuplicateError = ProjectDuplicateErrors[keyof ProjectDuplicateErrors];
export type ProjectDuplicateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ProjectDuplicateResponse = ProjectDuplicateResponses[keyof ProjectDuplicateResponses];
export type RedirectsCreateData = {
    body: {
        regex: string;
        replacement: string;
        permanent: boolean;
        applicationId: string;
    };
    path?: never;
    query?: never;
    url: "/redirects.create";
};
export type RedirectsCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedirectsCreateError = RedirectsCreateErrors[keyof RedirectsCreateErrors];
export type RedirectsCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedirectsCreateResponse = RedirectsCreateResponses[keyof RedirectsCreateResponses];
export type RedirectsOneData = {
    body?: never;
    path?: never;
    query: {
        redirectId: string;
    };
    url: "/redirects.one";
};
export type RedirectsOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedirectsOneError = RedirectsOneErrors[keyof RedirectsOneErrors];
export type RedirectsOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedirectsOneResponse = RedirectsOneResponses[keyof RedirectsOneResponses];
export type RedirectsDeleteData = {
    body: {
        redirectId: string;
    };
    path?: never;
    query?: never;
    url: "/redirects.delete";
};
export type RedirectsDeleteErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedirectsDeleteError = RedirectsDeleteErrors[keyof RedirectsDeleteErrors];
export type RedirectsDeleteResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedirectsDeleteResponse = RedirectsDeleteResponses[keyof RedirectsDeleteResponses];
export type RedirectsUpdateData = {
    body: {
        redirectId: string;
        regex: string;
        replacement: string;
        permanent: boolean;
    };
    path?: never;
    query?: never;
    url: "/redirects.update";
};
export type RedirectsUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedirectsUpdateError = RedirectsUpdateErrors[keyof RedirectsUpdateErrors];
export type RedirectsUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedirectsUpdateResponse = RedirectsUpdateResponses[keyof RedirectsUpdateResponses];
export type RedisCreateData = {
    body: {
        name: string;
        appName?: string;
        databasePassword: string;
        dockerImage?: string;
        environmentId: string;
        description?: string | null;
        serverId?: string | null;
    };
    path?: never;
    query?: never;
    url: "/redis.create";
};
export type RedisCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisCreateError = RedisCreateErrors[keyof RedisCreateErrors];
export type RedisCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisCreateResponse = RedisCreateResponses[keyof RedisCreateResponses];
export type RedisOneData = {
    body?: never;
    path?: never;
    query: {
        redisId: string;
    };
    url: "/redis.one";
};
export type RedisOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisOneError = RedisOneErrors[keyof RedisOneErrors];
export type RedisOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisOneResponse = RedisOneResponses[keyof RedisOneResponses];
export type RedisStartData = {
    body: {
        redisId: string;
    };
    path?: never;
    query?: never;
    url: "/redis.start";
};
export type RedisStartErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisStartError = RedisStartErrors[keyof RedisStartErrors];
export type RedisStartResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisStartResponse = RedisStartResponses[keyof RedisStartResponses];
export type RedisReloadData = {
    body: {
        redisId: string;
        appName: string;
    };
    path?: never;
    query?: never;
    url: "/redis.reload";
};
export type RedisReloadErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisReloadError = RedisReloadErrors[keyof RedisReloadErrors];
export type RedisReloadResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisReloadResponse = RedisReloadResponses[keyof RedisReloadResponses];
export type RedisStopData = {
    body: {
        redisId: string;
    };
    path?: never;
    query?: never;
    url: "/redis.stop";
};
export type RedisStopErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisStopError = RedisStopErrors[keyof RedisStopErrors];
export type RedisStopResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisStopResponse = RedisStopResponses[keyof RedisStopResponses];
export type RedisSaveExternalPortData = {
    body: {
        redisId: string;
        externalPort: number | null;
    };
    path?: never;
    query?: never;
    url: "/redis.saveExternalPort";
};
export type RedisSaveExternalPortErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisSaveExternalPortError = RedisSaveExternalPortErrors[keyof RedisSaveExternalPortErrors];
export type RedisSaveExternalPortResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisSaveExternalPortResponse = RedisSaveExternalPortResponses[keyof RedisSaveExternalPortResponses];
export type RedisDeployData = {
    body: {
        redisId: string;
    };
    path?: never;
    query?: never;
    url: "/redis.deploy";
};
export type RedisDeployErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisDeployError = RedisDeployErrors[keyof RedisDeployErrors];
export type RedisDeployResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisDeployResponse = RedisDeployResponses[keyof RedisDeployResponses];
export type RedisChangeStatusData = {
    body: {
        redisId: string;
        applicationStatus: "idle" | "running" | "done" | "error";
    };
    path?: never;
    query?: never;
    url: "/redis.changeStatus";
};
export type RedisChangeStatusErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisChangeStatusError = RedisChangeStatusErrors[keyof RedisChangeStatusErrors];
export type RedisChangeStatusResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisChangeStatusResponse = RedisChangeStatusResponses[keyof RedisChangeStatusResponses];
export type RedisRemoveData = {
    body: {
        redisId: string;
    };
    path?: never;
    query?: never;
    url: "/redis.remove";
};
export type RedisRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisRemoveError = RedisRemoveErrors[keyof RedisRemoveErrors];
export type RedisRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisRemoveResponse = RedisRemoveResponses[keyof RedisRemoveResponses];
export type RedisSaveEnvironmentData = {
    body: {
        redisId: string;
        env: string | null;
    };
    path?: never;
    query?: never;
    url: "/redis.saveEnvironment";
};
export type RedisSaveEnvironmentErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisSaveEnvironmentError = RedisSaveEnvironmentErrors[keyof RedisSaveEnvironmentErrors];
export type RedisSaveEnvironmentResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisSaveEnvironmentResponse = RedisSaveEnvironmentResponses[keyof RedisSaveEnvironmentResponses];
export type RedisUpdateData = {
    body: {
        redisId: string;
        name?: string;
        appName?: string;
        description?: string | null;
        databasePassword?: string;
        dockerImage?: string;
        command?: string | null;
        args?: Array<string> | null;
        env?: string | null;
        memoryReservation?: string | null;
        memoryLimit?: string | null;
        cpuReservation?: string | null;
        cpuLimit?: string | null;
        externalPort?: number | null;
        createdAt?: string;
        applicationStatus?: "idle" | "running" | "done" | "error";
        healthCheckSwarm?: {
            Test?: Array<string>;
            Interval?: number;
            Timeout?: number;
            StartPeriod?: number;
            Retries?: number;
        } | null | null;
        restartPolicySwarm?: {
            Condition?: string;
            Delay?: number;
            MaxAttempts?: number;
            Window?: number;
        } | null | null;
        placementSwarm?: {
            Constraints?: Array<string>;
            Preferences?: Array<{
                Spread: {
                    SpreadDescriptor: string;
                };
            }>;
            MaxReplicas?: number;
            Platforms?: Array<{
                Architecture: string;
                OS: string;
            }>;
        } | null | null;
        updateConfigSwarm?: {
            Parallelism: number;
            Delay?: number;
            FailureAction?: string;
            Monitor?: number;
            MaxFailureRatio?: number;
            Order: string;
        } | null | null;
        rollbackConfigSwarm?: {
            Parallelism: number;
            Delay?: number;
            FailureAction?: string;
            Monitor?: number;
            MaxFailureRatio?: number;
            Order: string;
        } | null | null;
        modeSwarm?: {
            Replicated?: {
                Replicas?: number;
            };
            Global?: {
                [key: string]: unknown;
            };
            ReplicatedJob?: {
                MaxConcurrent?: number;
                TotalCompletions?: number;
            };
            GlobalJob?: {
                [key: string]: unknown;
            };
        } | null | null;
        labelsSwarm?: {
            [key: string]: string;
        } | null | null;
        networkSwarm?: Array<{
            Target?: string;
            Aliases?: Array<string>;
            DriverOpts?: {
                [key: string]: string;
            };
        }> | null | null;
        stopGracePeriodSwarm?: number | null | null;
        endpointSpecSwarm?: {
            Mode?: string;
            Ports?: Array<{
                Protocol?: string;
                TargetPort?: number;
                PublishedPort?: number;
                PublishMode?: string;
            }>;
        } | null | null;
        ulimitsSwarm?: Array<{
            Name: string;
            Soft: number;
            Hard: number;
        }> | null | null;
        replicas?: number;
        environmentId?: string;
        networkIds?: Array<string> | null;
        detachDokployNetwork?: boolean;
    };
    path?: never;
    query?: never;
    url: "/redis.update";
};
export type RedisUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisUpdateError = RedisUpdateErrors[keyof RedisUpdateErrors];
export type RedisUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisUpdateResponse = RedisUpdateResponses[keyof RedisUpdateResponses];
export type RedisChangePasswordData = {
    body: {
        redisId: string;
        password: string;
    };
    path?: never;
    query?: never;
    url: "/redis.changePassword";
};
export type RedisChangePasswordErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisChangePasswordError = RedisChangePasswordErrors[keyof RedisChangePasswordErrors];
export type RedisChangePasswordResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisChangePasswordResponse = RedisChangePasswordResponses[keyof RedisChangePasswordResponses];
export type RedisMoveData = {
    body: {
        redisId: string;
        targetEnvironmentId: string;
    };
    path?: never;
    query?: never;
    url: "/redis.move";
};
export type RedisMoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisMoveError = RedisMoveErrors[keyof RedisMoveErrors];
export type RedisMoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisMoveResponse = RedisMoveResponses[keyof RedisMoveResponses];
export type RedisRebuildData = {
    body: {
        redisId: string;
    };
    path?: never;
    query?: never;
    url: "/redis.rebuild";
};
export type RedisRebuildErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisRebuildError = RedisRebuildErrors[keyof RedisRebuildErrors];
export type RedisRebuildResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisRebuildResponse = RedisRebuildResponses[keyof RedisRebuildResponses];
export type RedisSearchData = {
    body?: never;
    path?: never;
    query?: {
        q?: string;
        name?: string;
        appName?: string;
        description?: string;
        projectId?: string;
        environmentId?: string;
        limit?: number;
        offset?: number;
    };
    url: "/redis.search";
};
export type RedisSearchErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisSearchError = RedisSearchErrors[keyof RedisSearchErrors];
export type RedisSearchResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisSearchResponse = RedisSearchResponses[keyof RedisSearchResponses];
export type RedisReadLogsData = {
    body?: never;
    path?: never;
    query: {
        redisId: string;
        tail?: number;
        since?: string;
        search?: string;
    };
    url: "/redis.readLogs";
};
export type RedisReadLogsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RedisReadLogsError = RedisReadLogsErrors[keyof RedisReadLogsErrors];
export type RedisReadLogsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RedisReadLogsResponse = RedisReadLogsResponses[keyof RedisReadLogsResponses];
export type RegistryCreateData = {
    body: {
        registryName: string;
        username: string;
        password: string;
        registryUrl: string;
        registryType: "cloud";
        imagePrefix: string | null;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/registry.create";
};
export type RegistryCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RegistryCreateError = RegistryCreateErrors[keyof RegistryCreateErrors];
export type RegistryCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RegistryCreateResponse = RegistryCreateResponses[keyof RegistryCreateResponses];
export type RegistryRemoveData = {
    body: {
        registryId: string;
    };
    path?: never;
    query?: never;
    url: "/registry.remove";
};
export type RegistryRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RegistryRemoveError = RegistryRemoveErrors[keyof RegistryRemoveErrors];
export type RegistryRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RegistryRemoveResponse = RegistryRemoveResponses[keyof RegistryRemoveResponses];
export type RegistryUpdateData = {
    body: {
        registryId: string;
        registryName?: string;
        imagePrefix?: string | null | null;
        username?: string;
        password?: string;
        registryUrl?: string;
        createdAt?: string;
        registryType?: "cloud";
        organizationId?: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/registry.update";
};
export type RegistryUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RegistryUpdateError = RegistryUpdateErrors[keyof RegistryUpdateErrors];
export type RegistryUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RegistryUpdateResponse = RegistryUpdateResponses[keyof RegistryUpdateResponses];
export type RegistryAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/registry.all";
};
export type RegistryAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RegistryAllError = RegistryAllErrors[keyof RegistryAllErrors];
export type RegistryAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RegistryAllResponse = RegistryAllResponses[keyof RegistryAllResponses];
export type RegistryOneData = {
    body?: never;
    path?: never;
    query: {
        registryId: string;
    };
    url: "/registry.one";
};
export type RegistryOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RegistryOneError = RegistryOneErrors[keyof RegistryOneErrors];
export type RegistryOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RegistryOneResponse = RegistryOneResponses[keyof RegistryOneResponses];
export type RegistryTestRegistryData = {
    body: {
        registryName?: string;
        username: string;
        password: string;
        registryUrl: string;
        registryType: "cloud";
        imagePrefix?: string | null;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/registry.testRegistry";
};
export type RegistryTestRegistryErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RegistryTestRegistryError = RegistryTestRegistryErrors[keyof RegistryTestRegistryErrors];
export type RegistryTestRegistryResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RegistryTestRegistryResponse = RegistryTestRegistryResponses[keyof RegistryTestRegistryResponses];
export type RegistryTestRegistryByIdData = {
    body: {
        registryId?: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/registry.testRegistryById";
};
export type RegistryTestRegistryByIdErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RegistryTestRegistryByIdError = RegistryTestRegistryByIdErrors[keyof RegistryTestRegistryByIdErrors];
export type RegistryTestRegistryByIdResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RegistryTestRegistryByIdResponse = RegistryTestRegistryByIdResponses[keyof RegistryTestRegistryByIdResponses];
export type SecurityCreateData = {
    body: {
        applicationId: string;
        username: string;
        password: string;
    };
    path?: never;
    query?: never;
    url: "/security.create";
};
export type SecurityCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SecurityCreateError = SecurityCreateErrors[keyof SecurityCreateErrors];
export type SecurityCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SecurityCreateResponse = SecurityCreateResponses[keyof SecurityCreateResponses];
export type SecurityOneData = {
    body?: never;
    path?: never;
    query: {
        securityId: string;
    };
    url: "/security.one";
};
export type SecurityOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SecurityOneError = SecurityOneErrors[keyof SecurityOneErrors];
export type SecurityOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SecurityOneResponse = SecurityOneResponses[keyof SecurityOneResponses];
export type SecurityDeleteData = {
    body: {
        securityId: string;
    };
    path?: never;
    query?: never;
    url: "/security.delete";
};
export type SecurityDeleteErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SecurityDeleteError = SecurityDeleteErrors[keyof SecurityDeleteErrors];
export type SecurityDeleteResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SecurityDeleteResponse = SecurityDeleteResponses[keyof SecurityDeleteResponses];
export type SecurityUpdateData = {
    body: {
        securityId: string;
        username: string;
        password: string;
    };
    path?: never;
    query?: never;
    url: "/security.update";
};
export type SecurityUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SecurityUpdateError = SecurityUpdateErrors[keyof SecurityUpdateErrors];
export type SecurityUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SecurityUpdateResponse = SecurityUpdateResponses[keyof SecurityUpdateResponses];
export type ServerCreateData = {
    body: {
        name: string;
        description: string | null;
        ipAddress: string;
        port: number;
        username: string;
        sshKeyId: string | null;
        serverType: "deploy" | "build";
        enableDockerCleanup?: boolean;
    };
    path?: never;
    query?: never;
    url: "/server.create";
};
export type ServerCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerCreateError = ServerCreateErrors[keyof ServerCreateErrors];
export type ServerCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerCreateResponse = ServerCreateResponses[keyof ServerCreateResponses];
export type ServerOneData = {
    body?: never;
    path?: never;
    query: {
        serverId: string;
    };
    url: "/server.one";
};
export type ServerOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerOneError = ServerOneErrors[keyof ServerOneErrors];
export type ServerOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerOneResponse = ServerOneResponses[keyof ServerOneResponses];
export type ServerGetDefaultCommandData = {
    body?: never;
    path?: never;
    query: {
        serverId: string;
    };
    url: "/server.getDefaultCommand";
};
export type ServerGetDefaultCommandErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerGetDefaultCommandError = ServerGetDefaultCommandErrors[keyof ServerGetDefaultCommandErrors];
export type ServerGetDefaultCommandResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerGetDefaultCommandResponse = ServerGetDefaultCommandResponses[keyof ServerGetDefaultCommandResponses];
export type ServerGetServicesData = {
    body?: never;
    path?: never;
    query: {
        serverId: string;
    };
    url: "/server.getServices";
};
export type ServerGetServicesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerGetServicesError = ServerGetServicesErrors[keyof ServerGetServicesErrors];
export type ServerGetServicesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerGetServicesResponse = ServerGetServicesResponses[keyof ServerGetServicesResponses];
export type ServerAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/server.all";
};
export type ServerAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerAllError = ServerAllErrors[keyof ServerAllErrors];
export type ServerAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerAllResponse = ServerAllResponses[keyof ServerAllResponses];
export type ServerAllForPermissionsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/server.allForPermissions";
};
export type ServerAllForPermissionsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerAllForPermissionsError = ServerAllForPermissionsErrors[keyof ServerAllForPermissionsErrors];
export type ServerAllForPermissionsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerAllForPermissionsResponse = ServerAllForPermissionsResponses[keyof ServerAllForPermissionsResponses];
export type ServerCountData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/server.count";
};
export type ServerCountErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerCountError = ServerCountErrors[keyof ServerCountErrors];
export type ServerCountResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerCountResponse = ServerCountResponses[keyof ServerCountResponses];
export type ServerWithSshKeyData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/server.withSSHKey";
};
export type ServerWithSshKeyErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerWithSshKeyError = ServerWithSshKeyErrors[keyof ServerWithSshKeyErrors];
export type ServerWithSshKeyResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerWithSshKeyResponse = ServerWithSshKeyResponses[keyof ServerWithSshKeyResponses];
export type ServerBuildServersData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/server.buildServers";
};
export type ServerBuildServersErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerBuildServersError = ServerBuildServersErrors[keyof ServerBuildServersErrors];
export type ServerBuildServersResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerBuildServersResponse = ServerBuildServersResponses[keyof ServerBuildServersResponses];
export type ServerSetupData = {
    body: {
        serverId: string;
    };
    path?: never;
    query?: never;
    url: "/server.setup";
};
export type ServerSetupErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerSetupError = ServerSetupErrors[keyof ServerSetupErrors];
export type ServerSetupResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerSetupResponse = ServerSetupResponses[keyof ServerSetupResponses];
export type ServerValidateData = {
    body?: never;
    path?: never;
    query: {
        serverId: string;
    };
    url: "/server.validate";
};
export type ServerValidateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerValidateError = ServerValidateErrors[keyof ServerValidateErrors];
export type ServerValidateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerValidateResponse = ServerValidateResponses[keyof ServerValidateResponses];
export type ServerSecurityData = {
    body?: never;
    path?: never;
    query: {
        serverId: string;
    };
    url: "/server.security";
};
export type ServerSecurityErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerSecurityError = ServerSecurityErrors[keyof ServerSecurityErrors];
export type ServerSecurityResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerSecurityResponse = ServerSecurityResponses[keyof ServerSecurityResponses];
export type ServerSetupMonitoringData = {
    body: {
        serverId: string;
        metricsConfig: {
            server: {
                refreshRate: number;
                port: number;
                token: string;
                urlCallback: string;
                retentionDays: number;
                cronJob: string;
                thresholds: {
                    cpu: number;
                    memory: number;
                };
            };
            containers: {
                refreshRate: number;
                services: {
                    include?: Array<string>;
                    exclude?: Array<string>;
                };
            };
        };
    };
    path?: never;
    query?: never;
    url: "/server.setupMonitoring";
};
export type ServerSetupMonitoringErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerSetupMonitoringError = ServerSetupMonitoringErrors[keyof ServerSetupMonitoringErrors];
export type ServerSetupMonitoringResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerSetupMonitoringResponse = ServerSetupMonitoringResponses[keyof ServerSetupMonitoringResponses];
export type ServerRemoveData = {
    body: {
        serverId: string;
    };
    path?: never;
    query?: never;
    url: "/server.remove";
};
export type ServerRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerRemoveError = ServerRemoveErrors[keyof ServerRemoveErrors];
export type ServerRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerRemoveResponse = ServerRemoveResponses[keyof ServerRemoveResponses];
export type ServerUpdateData = {
    body: {
        name: string;
        description: string | null;
        serverId: string;
        ipAddress: string;
        port: number;
        username: string;
        sshKeyId: string | null;
        serverType: "deploy" | "build";
        enableDockerCleanup?: boolean;
        command?: string;
    };
    path?: never;
    query?: never;
    url: "/server.update";
};
export type ServerUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerUpdateError = ServerUpdateErrors[keyof ServerUpdateErrors];
export type ServerUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerUpdateResponse = ServerUpdateResponses[keyof ServerUpdateResponses];
export type ServerUpdateBuildsConcurrencyData = {
    body: {
        serverId: string;
        buildsConcurrency: number;
    };
    path?: never;
    query?: never;
    url: "/server.updateBuildsConcurrency";
};
export type ServerUpdateBuildsConcurrencyErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerUpdateBuildsConcurrencyError = ServerUpdateBuildsConcurrencyErrors[keyof ServerUpdateBuildsConcurrencyErrors];
export type ServerUpdateBuildsConcurrencyResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerUpdateBuildsConcurrencyResponse = ServerUpdateBuildsConcurrencyResponses[keyof ServerUpdateBuildsConcurrencyResponses];
export type ServerPublicIpData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/server.publicIp";
};
export type ServerPublicIpErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerPublicIpError = ServerPublicIpErrors[keyof ServerPublicIpErrors];
export type ServerPublicIpResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerPublicIpResponse = ServerPublicIpResponses[keyof ServerPublicIpResponses];
export type ServerGetServerTimeData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/server.getServerTime";
};
export type ServerGetServerTimeErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerGetServerTimeError = ServerGetServerTimeErrors[keyof ServerGetServerTimeErrors];
export type ServerGetServerTimeResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerGetServerTimeResponse = ServerGetServerTimeResponses[keyof ServerGetServerTimeResponses];
export type ServerGetServerMetricsData = {
    body?: never;
    path?: never;
    query: {
        url: string;
        token: string;
        dataPoints: string;
    };
    url: "/server.getServerMetrics";
};
export type ServerGetServerMetricsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ServerGetServerMetricsError = ServerGetServerMetricsErrors[keyof ServerGetServerMetricsErrors];
export type ServerGetServerMetricsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ServerGetServerMetricsResponse = ServerGetServerMetricsResponses[keyof ServerGetServerMetricsResponses];
export type SettingsGetWebServerSettingsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.getWebServerSettings";
};
export type SettingsGetWebServerSettingsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsGetWebServerSettingsError = SettingsGetWebServerSettingsErrors[keyof SettingsGetWebServerSettingsErrors];
export type SettingsGetWebServerSettingsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsGetWebServerSettingsResponse = SettingsGetWebServerSettingsResponses[keyof SettingsGetWebServerSettingsResponses];
export type SettingsReloadServerData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.reloadServer";
};
export type SettingsReloadServerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsReloadServerError = SettingsReloadServerErrors[keyof SettingsReloadServerErrors];
export type SettingsReloadServerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsReloadServerResponse = SettingsReloadServerResponses[keyof SettingsReloadServerResponses];
export type SettingsCleanAllDeploymentQueueData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.cleanAllDeploymentQueue";
};
export type SettingsCleanAllDeploymentQueueErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsCleanAllDeploymentQueueError = SettingsCleanAllDeploymentQueueErrors[keyof SettingsCleanAllDeploymentQueueErrors];
export type SettingsCleanAllDeploymentQueueResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsCleanAllDeploymentQueueResponse = SettingsCleanAllDeploymentQueueResponses[keyof SettingsCleanAllDeploymentQueueResponses];
export type SettingsReloadTraefikData = {
    body?: {
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/settings.reloadTraefik";
};
export type SettingsReloadTraefikErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsReloadTraefikError = SettingsReloadTraefikErrors[keyof SettingsReloadTraefikErrors];
export type SettingsReloadTraefikResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsReloadTraefikResponse = SettingsReloadTraefikResponses[keyof SettingsReloadTraefikResponses];
export type SettingsToggleDashboardData = {
    body: {
        enableDashboard?: boolean;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/settings.toggleDashboard";
};
export type SettingsToggleDashboardErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsToggleDashboardError = SettingsToggleDashboardErrors[keyof SettingsToggleDashboardErrors];
export type SettingsToggleDashboardResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsToggleDashboardResponse = SettingsToggleDashboardResponses[keyof SettingsToggleDashboardResponses];
export type SettingsCleanUnusedImagesData = {
    body?: {
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/settings.cleanUnusedImages";
};
export type SettingsCleanUnusedImagesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsCleanUnusedImagesError = SettingsCleanUnusedImagesErrors[keyof SettingsCleanUnusedImagesErrors];
export type SettingsCleanUnusedImagesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsCleanUnusedImagesResponse = SettingsCleanUnusedImagesResponses[keyof SettingsCleanUnusedImagesResponses];
export type SettingsCleanUnusedVolumesData = {
    body?: {
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/settings.cleanUnusedVolumes";
};
export type SettingsCleanUnusedVolumesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsCleanUnusedVolumesError = SettingsCleanUnusedVolumesErrors[keyof SettingsCleanUnusedVolumesErrors];
export type SettingsCleanUnusedVolumesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsCleanUnusedVolumesResponse = SettingsCleanUnusedVolumesResponses[keyof SettingsCleanUnusedVolumesResponses];
export type SettingsCleanStoppedContainersData = {
    body?: {
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/settings.cleanStoppedContainers";
};
export type SettingsCleanStoppedContainersErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsCleanStoppedContainersError = SettingsCleanStoppedContainersErrors[keyof SettingsCleanStoppedContainersErrors];
export type SettingsCleanStoppedContainersResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsCleanStoppedContainersResponse = SettingsCleanStoppedContainersResponses[keyof SettingsCleanStoppedContainersResponses];
export type SettingsCleanDockerBuilderData = {
    body?: {
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/settings.cleanDockerBuilder";
};
export type SettingsCleanDockerBuilderErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsCleanDockerBuilderError = SettingsCleanDockerBuilderErrors[keyof SettingsCleanDockerBuilderErrors];
export type SettingsCleanDockerBuilderResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsCleanDockerBuilderResponse = SettingsCleanDockerBuilderResponses[keyof SettingsCleanDockerBuilderResponses];
export type SettingsCleanDockerPruneData = {
    body?: {
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/settings.cleanDockerPrune";
};
export type SettingsCleanDockerPruneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsCleanDockerPruneError = SettingsCleanDockerPruneErrors[keyof SettingsCleanDockerPruneErrors];
export type SettingsCleanDockerPruneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsCleanDockerPruneResponse = SettingsCleanDockerPruneResponses[keyof SettingsCleanDockerPruneResponses];
export type SettingsCleanAllData = {
    body?: {
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/settings.cleanAll";
};
export type SettingsCleanAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsCleanAllError = SettingsCleanAllErrors[keyof SettingsCleanAllErrors];
export type SettingsCleanAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsCleanAllResponse = SettingsCleanAllResponses[keyof SettingsCleanAllResponses];
export type SettingsCleanMonitoringData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.cleanMonitoring";
};
export type SettingsCleanMonitoringErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsCleanMonitoringError = SettingsCleanMonitoringErrors[keyof SettingsCleanMonitoringErrors];
export type SettingsCleanMonitoringResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsCleanMonitoringResponse = SettingsCleanMonitoringResponses[keyof SettingsCleanMonitoringResponses];
export type SettingsGetDockerDiskUsageData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.getDockerDiskUsage";
};
export type SettingsGetDockerDiskUsageErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsGetDockerDiskUsageError = SettingsGetDockerDiskUsageErrors[keyof SettingsGetDockerDiskUsageErrors];
export type SettingsGetDockerDiskUsageResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsGetDockerDiskUsageResponse = SettingsGetDockerDiskUsageResponses[keyof SettingsGetDockerDiskUsageResponses];
export type SettingsSaveSshPrivateKeyData = {
    body: {
        sshPrivateKey: string;
    };
    path?: never;
    query?: never;
    url: "/settings.saveSSHPrivateKey";
};
export type SettingsSaveSshPrivateKeyErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsSaveSshPrivateKeyError = SettingsSaveSshPrivateKeyErrors[keyof SettingsSaveSshPrivateKeyErrors];
export type SettingsSaveSshPrivateKeyResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsSaveSshPrivateKeyResponse = SettingsSaveSshPrivateKeyResponses[keyof SettingsSaveSshPrivateKeyResponses];
export type SettingsAssignDomainServerData = {
    body: {
        host: string;
        certificateType: "letsencrypt" | "none" | "custom";
        letsEncryptEmail?: string | "" | null;
        https?: boolean;
    };
    path?: never;
    query?: never;
    url: "/settings.assignDomainServer";
};
export type SettingsAssignDomainServerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsAssignDomainServerError = SettingsAssignDomainServerErrors[keyof SettingsAssignDomainServerErrors];
export type SettingsAssignDomainServerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsAssignDomainServerResponse = SettingsAssignDomainServerResponses[keyof SettingsAssignDomainServerResponses];
export type SettingsCleanSshPrivateKeyData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.cleanSSHPrivateKey";
};
export type SettingsCleanSshPrivateKeyErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsCleanSshPrivateKeyError = SettingsCleanSshPrivateKeyErrors[keyof SettingsCleanSshPrivateKeyErrors];
export type SettingsCleanSshPrivateKeyResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsCleanSshPrivateKeyResponse = SettingsCleanSshPrivateKeyResponses[keyof SettingsCleanSshPrivateKeyResponses];
export type SettingsUpdateDockerCleanupData = {
    body: {
        enableDockerCleanup: boolean;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/settings.updateDockerCleanup";
};
export type SettingsUpdateDockerCleanupErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsUpdateDockerCleanupError = SettingsUpdateDockerCleanupErrors[keyof SettingsUpdateDockerCleanupErrors];
export type SettingsUpdateDockerCleanupResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsUpdateDockerCleanupResponse = SettingsUpdateDockerCleanupResponses[keyof SettingsUpdateDockerCleanupResponses];
export type SettingsUpdateRemoteServersOnlyData = {
    body: {
        remoteServersOnly: boolean;
    };
    path?: never;
    query?: never;
    url: "/settings.updateRemoteServersOnly";
};
export type SettingsUpdateRemoteServersOnlyErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsUpdateRemoteServersOnlyError = SettingsUpdateRemoteServersOnlyErrors[keyof SettingsUpdateRemoteServersOnlyErrors];
export type SettingsUpdateRemoteServersOnlyResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsUpdateRemoteServersOnlyResponse = SettingsUpdateRemoteServersOnlyResponses[keyof SettingsUpdateRemoteServersOnlyResponses];
export type SettingsUpdateBuildsConcurrencyData = {
    body: {
        buildsConcurrency: number;
    };
    path?: never;
    query?: never;
    url: "/settings.updateBuildsConcurrency";
};
export type SettingsUpdateBuildsConcurrencyErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsUpdateBuildsConcurrencyError = SettingsUpdateBuildsConcurrencyErrors[keyof SettingsUpdateBuildsConcurrencyErrors];
export type SettingsUpdateBuildsConcurrencyResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsUpdateBuildsConcurrencyResponse = SettingsUpdateBuildsConcurrencyResponses[keyof SettingsUpdateBuildsConcurrencyResponses];
export type SettingsUpdateEnforceSsoData = {
    body: {
        enforceSSO: boolean;
    };
    path?: never;
    query?: never;
    url: "/settings.updateEnforceSSO";
};
export type SettingsUpdateEnforceSsoErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsUpdateEnforceSsoError = SettingsUpdateEnforceSsoErrors[keyof SettingsUpdateEnforceSsoErrors];
export type SettingsUpdateEnforceSsoResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsUpdateEnforceSsoResponse = SettingsUpdateEnforceSsoResponses[keyof SettingsUpdateEnforceSsoResponses];
export type SettingsReadTraefikConfigData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.readTraefikConfig";
};
export type SettingsReadTraefikConfigErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsReadTraefikConfigError = SettingsReadTraefikConfigErrors[keyof SettingsReadTraefikConfigErrors];
export type SettingsReadTraefikConfigResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsReadTraefikConfigResponse = SettingsReadTraefikConfigResponses[keyof SettingsReadTraefikConfigResponses];
export type SettingsUpdateTraefikConfigData = {
    body: {
        traefikConfig: string;
    };
    path?: never;
    query?: never;
    url: "/settings.updateTraefikConfig";
};
export type SettingsUpdateTraefikConfigErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsUpdateTraefikConfigError = SettingsUpdateTraefikConfigErrors[keyof SettingsUpdateTraefikConfigErrors];
export type SettingsUpdateTraefikConfigResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsUpdateTraefikConfigResponse = SettingsUpdateTraefikConfigResponses[keyof SettingsUpdateTraefikConfigResponses];
export type SettingsReadWebServerTraefikConfigData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.readWebServerTraefikConfig";
};
export type SettingsReadWebServerTraefikConfigErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsReadWebServerTraefikConfigError = SettingsReadWebServerTraefikConfigErrors[keyof SettingsReadWebServerTraefikConfigErrors];
export type SettingsReadWebServerTraefikConfigResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsReadWebServerTraefikConfigResponse = SettingsReadWebServerTraefikConfigResponses[keyof SettingsReadWebServerTraefikConfigResponses];
export type SettingsUpdateWebServerTraefikConfigData = {
    body: {
        traefikConfig: string;
    };
    path?: never;
    query?: never;
    url: "/settings.updateWebServerTraefikConfig";
};
export type SettingsUpdateWebServerTraefikConfigErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsUpdateWebServerTraefikConfigError = SettingsUpdateWebServerTraefikConfigErrors[keyof SettingsUpdateWebServerTraefikConfigErrors];
export type SettingsUpdateWebServerTraefikConfigResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsUpdateWebServerTraefikConfigResponse = SettingsUpdateWebServerTraefikConfigResponses[keyof SettingsUpdateWebServerTraefikConfigResponses];
export type SettingsReadMiddlewareTraefikConfigData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.readMiddlewareTraefikConfig";
};
export type SettingsReadMiddlewareTraefikConfigErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsReadMiddlewareTraefikConfigError = SettingsReadMiddlewareTraefikConfigErrors[keyof SettingsReadMiddlewareTraefikConfigErrors];
export type SettingsReadMiddlewareTraefikConfigResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsReadMiddlewareTraefikConfigResponse = SettingsReadMiddlewareTraefikConfigResponses[keyof SettingsReadMiddlewareTraefikConfigResponses];
export type SettingsUpdateMiddlewareTraefikConfigData = {
    body: {
        traefikConfig: string;
    };
    path?: never;
    query?: never;
    url: "/settings.updateMiddlewareTraefikConfig";
};
export type SettingsUpdateMiddlewareTraefikConfigErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsUpdateMiddlewareTraefikConfigError = SettingsUpdateMiddlewareTraefikConfigErrors[keyof SettingsUpdateMiddlewareTraefikConfigErrors];
export type SettingsUpdateMiddlewareTraefikConfigResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsUpdateMiddlewareTraefikConfigResponse = SettingsUpdateMiddlewareTraefikConfigResponses[keyof SettingsUpdateMiddlewareTraefikConfigResponses];
export type SettingsGetUpdateDataData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.getUpdateData";
};
export type SettingsGetUpdateDataErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsGetUpdateDataError = SettingsGetUpdateDataErrors[keyof SettingsGetUpdateDataErrors];
export type SettingsGetUpdateDataResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsGetUpdateDataResponse = SettingsGetUpdateDataResponses[keyof SettingsGetUpdateDataResponses];
export type SettingsUpdateServerData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.updateServer";
};
export type SettingsUpdateServerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsUpdateServerError = SettingsUpdateServerErrors[keyof SettingsUpdateServerErrors];
export type SettingsUpdateServerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsUpdateServerResponse = SettingsUpdateServerResponses[keyof SettingsUpdateServerResponses];
export type SettingsGetDokployVersionData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.getDokployVersion";
};
export type SettingsGetDokployVersionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsGetDokployVersionError = SettingsGetDokployVersionErrors[keyof SettingsGetDokployVersionErrors];
export type SettingsGetDokployVersionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsGetDokployVersionResponse = SettingsGetDokployVersionResponses[keyof SettingsGetDokployVersionResponses];
export type SettingsGetReleaseTagData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.getReleaseTag";
};
export type SettingsGetReleaseTagErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsGetReleaseTagError = SettingsGetReleaseTagErrors[keyof SettingsGetReleaseTagErrors];
export type SettingsGetReleaseTagResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsGetReleaseTagResponse = SettingsGetReleaseTagResponses[keyof SettingsGetReleaseTagResponses];
export type SettingsReadDirectoriesData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/settings.readDirectories";
};
export type SettingsReadDirectoriesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsReadDirectoriesError = SettingsReadDirectoriesErrors[keyof SettingsReadDirectoriesErrors];
export type SettingsReadDirectoriesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsReadDirectoriesResponse = SettingsReadDirectoriesResponses[keyof SettingsReadDirectoriesResponses];
export type SettingsUpdateTraefikFileData = {
    body: {
        path: string;
        traefikConfig: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/settings.updateTraefikFile";
};
export type SettingsUpdateTraefikFileErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsUpdateTraefikFileError = SettingsUpdateTraefikFileErrors[keyof SettingsUpdateTraefikFileErrors];
export type SettingsUpdateTraefikFileResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsUpdateTraefikFileResponse = SettingsUpdateTraefikFileResponses[keyof SettingsUpdateTraefikFileResponses];
export type SettingsReadTraefikFileData = {
    body?: never;
    path?: never;
    query: {
        path: string;
        serverId?: string;
    };
    url: "/settings.readTraefikFile";
};
export type SettingsReadTraefikFileErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsReadTraefikFileError = SettingsReadTraefikFileErrors[keyof SettingsReadTraefikFileErrors];
export type SettingsReadTraefikFileResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsReadTraefikFileResponse = SettingsReadTraefikFileResponses[keyof SettingsReadTraefikFileResponses];
export type SettingsGetIpData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.getIp";
};
export type SettingsGetIpErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsGetIpError = SettingsGetIpErrors[keyof SettingsGetIpErrors];
export type SettingsGetIpResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsGetIpResponse = SettingsGetIpResponses[keyof SettingsGetIpResponses];
export type SettingsUpdateServerIpData = {
    body: {
        serverIp: string;
    };
    path?: never;
    query?: never;
    url: "/settings.updateServerIp";
};
export type SettingsUpdateServerIpErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsUpdateServerIpError = SettingsUpdateServerIpErrors[keyof SettingsUpdateServerIpErrors];
export type SettingsUpdateServerIpResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsUpdateServerIpResponse = SettingsUpdateServerIpResponses[keyof SettingsUpdateServerIpResponses];
export type SettingsGetOpenApiDocumentData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.getOpenApiDocument";
};
export type SettingsGetOpenApiDocumentErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsGetOpenApiDocumentError = SettingsGetOpenApiDocumentErrors[keyof SettingsGetOpenApiDocumentErrors];
export type SettingsGetOpenApiDocumentResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsGetOpenApiDocumentResponse = SettingsGetOpenApiDocumentResponses[keyof SettingsGetOpenApiDocumentResponses];
export type SettingsReadTraefikEnvData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/settings.readTraefikEnv";
};
export type SettingsReadTraefikEnvErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsReadTraefikEnvError = SettingsReadTraefikEnvErrors[keyof SettingsReadTraefikEnvErrors];
export type SettingsReadTraefikEnvResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsReadTraefikEnvResponse = SettingsReadTraefikEnvResponses[keyof SettingsReadTraefikEnvResponses];
export type SettingsWriteTraefikEnvData = {
    body: {
        env: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/settings.writeTraefikEnv";
};
export type SettingsWriteTraefikEnvErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsWriteTraefikEnvError = SettingsWriteTraefikEnvErrors[keyof SettingsWriteTraefikEnvErrors];
export type SettingsWriteTraefikEnvResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsWriteTraefikEnvResponse = SettingsWriteTraefikEnvResponses[keyof SettingsWriteTraefikEnvResponses];
export type SettingsHaveTraefikDashboardPortEnabledData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/settings.haveTraefikDashboardPortEnabled";
};
export type SettingsHaveTraefikDashboardPortEnabledErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsHaveTraefikDashboardPortEnabledError = SettingsHaveTraefikDashboardPortEnabledErrors[keyof SettingsHaveTraefikDashboardPortEnabledErrors];
export type SettingsHaveTraefikDashboardPortEnabledResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsHaveTraefikDashboardPortEnabledResponse = SettingsHaveTraefikDashboardPortEnabledResponses[keyof SettingsHaveTraefikDashboardPortEnabledResponses];
export type SettingsHaveActivateRequestsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.haveActivateRequests";
};
export type SettingsHaveActivateRequestsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsHaveActivateRequestsError = SettingsHaveActivateRequestsErrors[keyof SettingsHaveActivateRequestsErrors];
export type SettingsHaveActivateRequestsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsHaveActivateRequestsResponse = SettingsHaveActivateRequestsResponses[keyof SettingsHaveActivateRequestsResponses];
export type SettingsToggleRequestsData = {
    body: {
        enable: boolean;
    };
    path?: never;
    query?: never;
    url: "/settings.toggleRequests";
};
export type SettingsToggleRequestsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsToggleRequestsError = SettingsToggleRequestsErrors[keyof SettingsToggleRequestsErrors];
export type SettingsToggleRequestsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsToggleRequestsResponse = SettingsToggleRequestsResponses[keyof SettingsToggleRequestsResponses];
export type SettingsIsCloudData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.isCloud";
};
export type SettingsIsCloudErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsIsCloudError = SettingsIsCloudErrors[keyof SettingsIsCloudErrors];
export type SettingsIsCloudResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsIsCloudResponse = SettingsIsCloudResponses[keyof SettingsIsCloudResponses];
export type SettingsIsUserSubscribedData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.isUserSubscribed";
};
export type SettingsIsUserSubscribedErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsIsUserSubscribedError = SettingsIsUserSubscribedErrors[keyof SettingsIsUserSubscribedErrors];
export type SettingsIsUserSubscribedResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsIsUserSubscribedResponse = SettingsIsUserSubscribedResponses[keyof SettingsIsUserSubscribedResponses];
export type SettingsHealthData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.health";
};
export type SettingsHealthErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsHealthError = SettingsHealthErrors[keyof SettingsHealthErrors];
export type SettingsHealthResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsHealthResponse = SettingsHealthResponses[keyof SettingsHealthResponses];
export type SettingsCheckInfrastructureHealthData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.checkInfrastructureHealth";
};
export type SettingsCheckInfrastructureHealthErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsCheckInfrastructureHealthError = SettingsCheckInfrastructureHealthErrors[keyof SettingsCheckInfrastructureHealthErrors];
export type SettingsCheckInfrastructureHealthResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsCheckInfrastructureHealthResponse = SettingsCheckInfrastructureHealthResponses[keyof SettingsCheckInfrastructureHealthResponses];
export type SettingsSetupGpuData = {
    body: {
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/settings.setupGPU";
};
export type SettingsSetupGpuErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsSetupGpuError = SettingsSetupGpuErrors[keyof SettingsSetupGpuErrors];
export type SettingsSetupGpuResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsSetupGpuResponse = SettingsSetupGpuResponses[keyof SettingsSetupGpuResponses];
export type SettingsCheckGpuStatusData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/settings.checkGPUStatus";
};
export type SettingsCheckGpuStatusErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsCheckGpuStatusError = SettingsCheckGpuStatusErrors[keyof SettingsCheckGpuStatusErrors];
export type SettingsCheckGpuStatusResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsCheckGpuStatusResponse = SettingsCheckGpuStatusResponses[keyof SettingsCheckGpuStatusResponses];
export type SettingsUpdateTraefikPortsData = {
    body: {
        serverId?: string;
        additionalPorts: Array<{
            targetPort: number;
            publishedPort: number;
            protocol: "tcp" | "udp" | "sctp";
        }>;
    };
    path?: never;
    query?: never;
    url: "/settings.updateTraefikPorts";
};
export type SettingsUpdateTraefikPortsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsUpdateTraefikPortsError = SettingsUpdateTraefikPortsErrors[keyof SettingsUpdateTraefikPortsErrors];
export type SettingsUpdateTraefikPortsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsUpdateTraefikPortsResponse = SettingsUpdateTraefikPortsResponses[keyof SettingsUpdateTraefikPortsResponses];
export type SettingsGetTraefikPortsData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/settings.getTraefikPorts";
};
export type SettingsGetTraefikPortsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsGetTraefikPortsError = SettingsGetTraefikPortsErrors[keyof SettingsGetTraefikPortsErrors];
export type SettingsGetTraefikPortsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsGetTraefikPortsResponse = SettingsGetTraefikPortsResponses[keyof SettingsGetTraefikPortsResponses];
export type SettingsUpdateLogCleanupData = {
    body: {
        cronExpression: string | null;
    };
    path?: never;
    query?: never;
    url: "/settings.updateLogCleanup";
};
export type SettingsUpdateLogCleanupErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsUpdateLogCleanupError = SettingsUpdateLogCleanupErrors[keyof SettingsUpdateLogCleanupErrors];
export type SettingsUpdateLogCleanupResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsUpdateLogCleanupResponse = SettingsUpdateLogCleanupResponses[keyof SettingsUpdateLogCleanupResponses];
export type SettingsGetLogCleanupStatusData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.getLogCleanupStatus";
};
export type SettingsGetLogCleanupStatusErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsGetLogCleanupStatusError = SettingsGetLogCleanupStatusErrors[keyof SettingsGetLogCleanupStatusErrors];
export type SettingsGetLogCleanupStatusResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsGetLogCleanupStatusResponse = SettingsGetLogCleanupStatusResponses[keyof SettingsGetLogCleanupStatusResponses];
export type SettingsGetDokployCloudIpsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/settings.getDokployCloudIps";
};
export type SettingsGetDokployCloudIpsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SettingsGetDokployCloudIpsError = SettingsGetDokployCloudIpsErrors[keyof SettingsGetDokployCloudIpsErrors];
export type SettingsGetDokployCloudIpsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SettingsGetDokployCloudIpsResponse = SettingsGetDokployCloudIpsResponses[keyof SettingsGetDokployCloudIpsResponses];
export type SshKeyCreateData = {
    body: {
        name: string;
        description?: string | null;
        privateKey: string;
        publicKey: string;
        organizationId: string;
    };
    path?: never;
    query?: never;
    url: "/sshKey.create";
};
export type SshKeyCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SshKeyCreateError = SshKeyCreateErrors[keyof SshKeyCreateErrors];
export type SshKeyCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SshKeyCreateResponse = SshKeyCreateResponses[keyof SshKeyCreateResponses];
export type SshKeyRemoveData = {
    body: {
        sshKeyId: string;
    };
    path?: never;
    query?: never;
    url: "/sshKey.remove";
};
export type SshKeyRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SshKeyRemoveError = SshKeyRemoveErrors[keyof SshKeyRemoveErrors];
export type SshKeyRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SshKeyRemoveResponse = SshKeyRemoveResponses[keyof SshKeyRemoveResponses];
export type SshKeyOneData = {
    body?: never;
    path?: never;
    query: {
        sshKeyId: string;
    };
    url: "/sshKey.one";
};
export type SshKeyOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SshKeyOneError = SshKeyOneErrors[keyof SshKeyOneErrors];
export type SshKeyOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SshKeyOneResponse = SshKeyOneResponses[keyof SshKeyOneResponses];
export type SshKeyAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/sshKey.all";
};
export type SshKeyAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SshKeyAllError = SshKeyAllErrors[keyof SshKeyAllErrors];
export type SshKeyAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SshKeyAllResponse = SshKeyAllResponses[keyof SshKeyAllResponses];
export type SshKeyAllForAppsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/sshKey.allForApps";
};
export type SshKeyAllForAppsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SshKeyAllForAppsError = SshKeyAllForAppsErrors[keyof SshKeyAllForAppsErrors];
export type SshKeyAllForAppsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SshKeyAllForAppsResponse = SshKeyAllForAppsResponses[keyof SshKeyAllForAppsResponses];
export type SshKeyGenerateData = {
    body: {
        type?: "rsa" | "ed25519";
    };
    path?: never;
    query?: never;
    url: "/sshKey.generate";
};
export type SshKeyGenerateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SshKeyGenerateError = SshKeyGenerateErrors[keyof SshKeyGenerateErrors];
export type SshKeyGenerateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SshKeyGenerateResponse = SshKeyGenerateResponses[keyof SshKeyGenerateResponses];
export type SshKeyUpdateData = {
    body: {
        name?: string;
        description?: string | null;
        lastUsedAt?: string | null;
        sshKeyId: string;
    };
    path?: never;
    query?: never;
    url: "/sshKey.update";
};
export type SshKeyUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SshKeyUpdateError = SshKeyUpdateErrors[keyof SshKeyUpdateErrors];
export type SshKeyUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SshKeyUpdateResponse = SshKeyUpdateResponses[keyof SshKeyUpdateResponses];
export type StripeGetCurrentPlanData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/stripe.getCurrentPlan";
};
export type StripeGetCurrentPlanErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type StripeGetCurrentPlanError = StripeGetCurrentPlanErrors[keyof StripeGetCurrentPlanErrors];
export type StripeGetCurrentPlanResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type StripeGetCurrentPlanResponse = StripeGetCurrentPlanResponses[keyof StripeGetCurrentPlanResponses];
export type StripeGetBillingStatusData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/stripe.getBillingStatus";
};
export type StripeGetBillingStatusErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type StripeGetBillingStatusError = StripeGetBillingStatusErrors[keyof StripeGetBillingStatusErrors];
export type StripeGetBillingStatusResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type StripeGetBillingStatusResponse = StripeGetBillingStatusResponses[keyof StripeGetBillingStatusResponses];
export type StripeStartFreeTrialData = {
    body: {
        tier: "hobby" | "startup";
    };
    path?: never;
    query?: never;
    url: "/stripe.startFreeTrial";
};
export type StripeStartFreeTrialErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type StripeStartFreeTrialError = StripeStartFreeTrialErrors[keyof StripeStartFreeTrialErrors];
export type StripeStartFreeTrialResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type StripeStartFreeTrialResponse = StripeStartFreeTrialResponses[keyof StripeStartFreeTrialResponses];
export type StripeGetProductsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/stripe.getProducts";
};
export type StripeGetProductsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type StripeGetProductsError = StripeGetProductsErrors[keyof StripeGetProductsErrors];
export type StripeGetProductsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type StripeGetProductsResponse = StripeGetProductsResponses[keyof StripeGetProductsResponses];
export type StripeCreateCheckoutSessionData = {
    body: {
        tier: "legacy" | "hobby" | "startup";
        productId: string;
        serverQuantity: number;
        isAnnual: boolean;
    };
    path?: never;
    query?: never;
    url: "/stripe.createCheckoutSession";
};
export type StripeCreateCheckoutSessionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type StripeCreateCheckoutSessionError = StripeCreateCheckoutSessionErrors[keyof StripeCreateCheckoutSessionErrors];
export type StripeCreateCheckoutSessionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type StripeCreateCheckoutSessionResponse = StripeCreateCheckoutSessionResponses[keyof StripeCreateCheckoutSessionResponses];
export type StripeCreateCustomerPortalSessionData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/stripe.createCustomerPortalSession";
};
export type StripeCreateCustomerPortalSessionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type StripeCreateCustomerPortalSessionError = StripeCreateCustomerPortalSessionErrors[keyof StripeCreateCustomerPortalSessionErrors];
export type StripeCreateCustomerPortalSessionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type StripeCreateCustomerPortalSessionResponse = StripeCreateCustomerPortalSessionResponses[keyof StripeCreateCustomerPortalSessionResponses];
export type StripeUpgradeSubscriptionData = {
    body: {
        tier: "hobby" | "startup";
        serverQuantity: number;
        isAnnual: boolean;
    };
    path?: never;
    query?: never;
    url: "/stripe.upgradeSubscription";
};
export type StripeUpgradeSubscriptionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type StripeUpgradeSubscriptionError = StripeUpgradeSubscriptionErrors[keyof StripeUpgradeSubscriptionErrors];
export type StripeUpgradeSubscriptionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type StripeUpgradeSubscriptionResponse = StripeUpgradeSubscriptionResponses[keyof StripeUpgradeSubscriptionResponses];
export type StripeCanCreateMoreServersData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/stripe.canCreateMoreServers";
};
export type StripeCanCreateMoreServersErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type StripeCanCreateMoreServersError = StripeCanCreateMoreServersErrors[keyof StripeCanCreateMoreServersErrors];
export type StripeCanCreateMoreServersResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type StripeCanCreateMoreServersResponse = StripeCanCreateMoreServersResponses[keyof StripeCanCreateMoreServersResponses];
export type StripeUpdateInvoiceNotificationsData = {
    body: {
        enabled: boolean;
    };
    path?: never;
    query?: never;
    url: "/stripe.updateInvoiceNotifications";
};
export type StripeUpdateInvoiceNotificationsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type StripeUpdateInvoiceNotificationsError = StripeUpdateInvoiceNotificationsErrors[keyof StripeUpdateInvoiceNotificationsErrors];
export type StripeUpdateInvoiceNotificationsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type StripeUpdateInvoiceNotificationsResponse = StripeUpdateInvoiceNotificationsResponses[keyof StripeUpdateInvoiceNotificationsResponses];
export type StripeGetInvoicesData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/stripe.getInvoices";
};
export type StripeGetInvoicesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type StripeGetInvoicesError = StripeGetInvoicesErrors[keyof StripeGetInvoicesErrors];
export type StripeGetInvoicesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type StripeGetInvoicesResponse = StripeGetInvoicesResponses[keyof StripeGetInvoicesResponses];
export type SwarmGetNodesData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/swarm.getNodes";
};
export type SwarmGetNodesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SwarmGetNodesError = SwarmGetNodesErrors[keyof SwarmGetNodesErrors];
export type SwarmGetNodesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SwarmGetNodesResponse = SwarmGetNodesResponses[keyof SwarmGetNodesResponses];
export type SwarmGetNodeInfoData = {
    body?: never;
    path?: never;
    query: {
        nodeId: string;
        serverId?: string;
    };
    url: "/swarm.getNodeInfo";
};
export type SwarmGetNodeInfoErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SwarmGetNodeInfoError = SwarmGetNodeInfoErrors[keyof SwarmGetNodeInfoErrors];
export type SwarmGetNodeInfoResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SwarmGetNodeInfoResponse = SwarmGetNodeInfoResponses[keyof SwarmGetNodeInfoResponses];
export type SwarmGetNodeAppsData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/swarm.getNodeApps";
};
export type SwarmGetNodeAppsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SwarmGetNodeAppsError = SwarmGetNodeAppsErrors[keyof SwarmGetNodeAppsErrors];
export type SwarmGetNodeAppsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SwarmGetNodeAppsResponse = SwarmGetNodeAppsResponses[keyof SwarmGetNodeAppsResponses];
export type SwarmGetContainerStatsData = {
    body?: never;
    path?: never;
    query?: {
        serverId?: string;
    };
    url: "/swarm.getContainerStats";
};
export type SwarmGetContainerStatsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SwarmGetContainerStatsError = SwarmGetContainerStatsErrors[keyof SwarmGetContainerStatsErrors];
export type SwarmGetContainerStatsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SwarmGetContainerStatsResponse = SwarmGetContainerStatsResponses[keyof SwarmGetContainerStatsResponses];
export type UserAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/user.all";
};
export type UserAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserAllError = UserAllErrors[keyof UserAllErrors];
export type UserAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserAllResponse = UserAllResponses[keyof UserAllResponses];
export type UserOneData = {
    body?: never;
    path?: never;
    query: {
        userId: string;
    };
    url: "/user.one";
};
export type UserOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserOneError = UserOneErrors[keyof UserOneErrors];
export type UserOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserOneResponse = UserOneResponses[keyof UserOneResponses];
export type UserSessionData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/user.session";
};
export type UserSessionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserSessionError = UserSessionErrors[keyof UserSessionErrors];
export type UserSessionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserSessionResponse = UserSessionResponses[keyof UserSessionResponses];
export type UserGetData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/user.get";
};
export type UserGetErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserGetError = UserGetErrors[keyof UserGetErrors];
export type UserGetResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserGetResponse = UserGetResponses[keyof UserGetResponses];
export type UserGetPermissionsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/user.getPermissions";
};
export type UserGetPermissionsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserGetPermissionsError = UserGetPermissionsErrors[keyof UserGetPermissionsErrors];
export type UserGetPermissionsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserGetPermissionsResponse = UserGetPermissionsResponses[keyof UserGetPermissionsResponses];
export type UserListPasskeysData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/user.listPasskeys";
};
export type UserListPasskeysErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserListPasskeysError = UserListPasskeysErrors[keyof UserListPasskeysErrors];
export type UserListPasskeysResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserListPasskeysResponse = UserListPasskeysResponses[keyof UserListPasskeysResponses];
export type UserHaveRootAccessData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/user.haveRootAccess";
};
export type UserHaveRootAccessErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserHaveRootAccessError = UserHaveRootAccessErrors[keyof UserHaveRootAccessErrors];
export type UserHaveRootAccessResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserHaveRootAccessResponse = UserHaveRootAccessResponses[keyof UserHaveRootAccessResponses];
export type UserGetBackupsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/user.getBackups";
};
export type UserGetBackupsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserGetBackupsError = UserGetBackupsErrors[keyof UserGetBackupsErrors];
export type UserGetBackupsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserGetBackupsResponse = UserGetBackupsResponses[keyof UserGetBackupsResponses];
export type UserGetServerMetricsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/user.getServerMetrics";
};
export type UserGetServerMetricsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserGetServerMetricsError = UserGetServerMetricsErrors[keyof UserGetServerMetricsErrors];
export type UserGetServerMetricsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserGetServerMetricsResponse = UserGetServerMetricsResponses[keyof UserGetServerMetricsResponses];
export type UserUpdateData = {
    body: {
        id?: string;
        firstName?: string;
        lastName?: string;
        isRegistered?: boolean;
        expirationDate?: string;
        createdAt2?: string;
        createdAt?: string | null;
        twoFactorEnabled?: boolean | null;
        email?: string;
        emailVerified?: boolean;
        image?: string | null;
        banned?: boolean | null;
        banReason?: string | null;
        banExpires?: string | null;
        updatedAt?: string;
        enablePaidFeatures?: boolean;
        allowImpersonation?: boolean;
        enableEnterpriseFeatures?: boolean;
        licenseKey?: string | null;
        stripeCustomerId?: string | null;
        stripeSubscriptionId?: string | null;
        serversQuantity?: number;
        sendInvoiceNotifications?: boolean;
        password?: string;
        currentPassword?: string;
    };
    path?: never;
    query?: never;
    url: "/user.update";
};
export type UserUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserUpdateError = UserUpdateErrors[keyof UserUpdateErrors];
export type UserUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserUpdateResponse = UserUpdateResponses[keyof UserUpdateResponses];
export type UserListSessionsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/user.listSessions";
};
export type UserListSessionsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserListSessionsError = UserListSessionsErrors[keyof UserListSessionsErrors];
export type UserListSessionsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserListSessionsResponse = UserListSessionsResponses[keyof UserListSessionsResponses];
export type UserRevokeSessionData = {
    body: {
        sessionId: string;
    };
    path?: never;
    query?: never;
    url: "/user.revokeSession";
};
export type UserRevokeSessionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserRevokeSessionError = UserRevokeSessionErrors[keyof UserRevokeSessionErrors];
export type UserRevokeSessionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserRevokeSessionResponse = UserRevokeSessionResponses[keyof UserRevokeSessionResponses];
export type UserGetUserByTokenData = {
    body?: never;
    path?: never;
    query: {
        token: string;
    };
    url: "/user.getUserByToken";
};
export type UserGetUserByTokenErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserGetUserByTokenError = UserGetUserByTokenErrors[keyof UserGetUserByTokenErrors];
export type UserGetUserByTokenResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserGetUserByTokenResponse = UserGetUserByTokenResponses[keyof UserGetUserByTokenResponses];
export type UserGetMetricsTokenData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/user.getMetricsToken";
};
export type UserGetMetricsTokenErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserGetMetricsTokenError = UserGetMetricsTokenErrors[keyof UserGetMetricsTokenErrors];
export type UserGetMetricsTokenResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserGetMetricsTokenResponse = UserGetMetricsTokenResponses[keyof UserGetMetricsTokenResponses];
export type UserRemoveData = {
    body: {
        userId: string;
    };
    path?: never;
    query?: never;
    url: "/user.remove";
};
export type UserRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserRemoveError = UserRemoveErrors[keyof UserRemoveErrors];
export type UserRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserRemoveResponse = UserRemoveResponses[keyof UserRemoveResponses];
export type UserAssignPermissionsData = {
    body: {
        id: string;
        accessedProjects: Array<string>;
        accessedEnvironments: Array<string>;
        accessedServices: Array<string>;
        accessedGitProviders: Array<string>;
        accessedServers: Array<string>;
        canCreateProjects: boolean;
        canCreateServices: boolean;
        canDeleteProjects: boolean;
        canDeleteServices: boolean;
        canAccessToDocker: boolean;
        canAccessToTraefikFiles: boolean;
        canAccessToAPI: boolean;
        canAccessToSSHKeys: boolean;
        canAccessToGitProviders: boolean;
        canDeleteEnvironments: boolean;
        canCreateEnvironments: boolean;
    };
    path?: never;
    query?: never;
    url: "/user.assignPermissions";
};
export type UserAssignPermissionsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserAssignPermissionsError = UserAssignPermissionsErrors[keyof UserAssignPermissionsErrors];
export type UserAssignPermissionsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserAssignPermissionsResponse = UserAssignPermissionsResponses[keyof UserAssignPermissionsResponses];
export type UserGetInvitationsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/user.getInvitations";
};
export type UserGetInvitationsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserGetInvitationsError = UserGetInvitationsErrors[keyof UserGetInvitationsErrors];
export type UserGetInvitationsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserGetInvitationsResponse = UserGetInvitationsResponses[keyof UserGetInvitationsResponses];
export type UserGetContainerMetricsData = {
    body?: never;
    path?: never;
    query: {
        url: string;
        token: string;
        appName: string;
        dataPoints: string;
    };
    url: "/user.getContainerMetrics";
};
export type UserGetContainerMetricsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserGetContainerMetricsError = UserGetContainerMetricsErrors[keyof UserGetContainerMetricsErrors];
export type UserGetContainerMetricsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserGetContainerMetricsResponse = UserGetContainerMetricsResponses[keyof UserGetContainerMetricsResponses];
export type UserGenerateTokenData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/user.generateToken";
};
export type UserGenerateTokenErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserGenerateTokenError = UserGenerateTokenErrors[keyof UserGenerateTokenErrors];
export type UserGenerateTokenResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserGenerateTokenResponse = UserGenerateTokenResponses[keyof UserGenerateTokenResponses];
export type UserDeleteApiKeyData = {
    body: {
        apiKeyId: string;
    };
    path?: never;
    query?: never;
    url: "/user.deleteApiKey";
};
export type UserDeleteApiKeyErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserDeleteApiKeyError = UserDeleteApiKeyErrors[keyof UserDeleteApiKeyErrors];
export type UserDeleteApiKeyResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserDeleteApiKeyResponse = UserDeleteApiKeyResponses[keyof UserDeleteApiKeyResponses];
export type UserCreateApiKeyData = {
    body: {
        name: string;
        prefix?: string;
        expiresIn?: number;
        metadata: {
            organizationId: string;
        };
        rateLimitEnabled?: boolean;
        rateLimitTimeWindow?: number;
        rateLimitMax?: number;
        remaining?: number;
        refillAmount?: number;
        refillInterval?: number;
    };
    path?: never;
    query?: never;
    url: "/user.createApiKey";
};
export type UserCreateApiKeyErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserCreateApiKeyError = UserCreateApiKeyErrors[keyof UserCreateApiKeyErrors];
export type UserCreateApiKeyResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserCreateApiKeyResponse = UserCreateApiKeyResponses[keyof UserCreateApiKeyResponses];
export type UserCheckUserOrganizationsData = {
    body?: never;
    path?: never;
    query: {
        userId: string;
    };
    url: "/user.checkUserOrganizations";
};
export type UserCheckUserOrganizationsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserCheckUserOrganizationsError = UserCheckUserOrganizationsErrors[keyof UserCheckUserOrganizationsErrors];
export type UserCheckUserOrganizationsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserCheckUserOrganizationsResponse = UserCheckUserOrganizationsResponses[keyof UserCheckUserOrganizationsResponses];
export type UserCreateUserWithCredentialsData = {
    body: {
        email: string;
        password: string;
        role: string;
    };
    path?: never;
    query?: never;
    url: "/user.createUserWithCredentials";
};
export type UserCreateUserWithCredentialsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserCreateUserWithCredentialsError = UserCreateUserWithCredentialsErrors[keyof UserCreateUserWithCredentialsErrors];
export type UserCreateUserWithCredentialsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserCreateUserWithCredentialsResponse = UserCreateUserWithCredentialsResponses[keyof UserCreateUserWithCredentialsResponses];
export type UserSendInvitationData = {
    body: {
        invitationId: string;
        notificationId: string;
    };
    path?: never;
    query?: never;
    url: "/user.sendInvitation";
};
export type UserSendInvitationErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserSendInvitationError = UserSendInvitationErrors[keyof UserSendInvitationErrors];
export type UserSendInvitationResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserSendInvitationResponse = UserSendInvitationResponses[keyof UserSendInvitationResponses];
export type UserGetBookmarkedTemplatesData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/user.getBookmarkedTemplates";
};
export type UserGetBookmarkedTemplatesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserGetBookmarkedTemplatesError = UserGetBookmarkedTemplatesErrors[keyof UserGetBookmarkedTemplatesErrors];
export type UserGetBookmarkedTemplatesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserGetBookmarkedTemplatesResponse = UserGetBookmarkedTemplatesResponses[keyof UserGetBookmarkedTemplatesResponses];
export type UserToggleTemplateBookmarkData = {
    body: {
        templateId: string;
    };
    path?: never;
    query?: never;
    url: "/user.toggleTemplateBookmark";
};
export type UserToggleTemplateBookmarkErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type UserToggleTemplateBookmarkError = UserToggleTemplateBookmarkErrors[keyof UserToggleTemplateBookmarkErrors];
export type UserToggleTemplateBookmarkResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type UserToggleTemplateBookmarkResponse = UserToggleTemplateBookmarkResponses[keyof UserToggleTemplateBookmarkResponses];
export type VaultProviderCreateData = {
    body: {
        name: string;
        config: {
            providerType: "hashicorp";
            url: string;
            token: string;
            namespace?: string;
            mount?: string;
        } | {
            providerType: "infisical";
            siteUrl?: string;
            clientId: string;
            clientSecret: string;
            projectId: string;
            environmentSlug: string;
            secretPath?: string;
        } | {
            providerType: "aws";
            region: string;
            accessKeyId: string;
            secretAccessKey: string;
            endpoint?: string;
        } | {
            providerType: "aws-parameter-store";
            region: string;
            accessKeyId: string;
            secretAccessKey: string;
            endpoint?: string;
            parameterPath?: string;
        } | {
            providerType: "doppler";
            serviceToken: string;
            project?: string;
            config?: string;
        } | {
            providerType: "azure";
            vaultUri: string;
            tenantId: string;
            clientId: string;
            clientSecret: string;
        } | {
            providerType: "scaleway";
            region?: string;
            projectId: string;
            secretKey: string;
            apiUrl?: string;
        } | {
            providerType: "phase";
            token: string;
            appId: string;
            env: string;
            path?: string;
            apiUrl?: string;
        };
        assignments: Array<{
            projectId: string;
            environmentIds?: Array<string>;
        }>;
    };
    path?: never;
    query?: never;
    url: "/vaultProvider.create";
};
export type VaultProviderCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type VaultProviderCreateError = VaultProviderCreateErrors[keyof VaultProviderCreateErrors];
export type VaultProviderCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type VaultProviderCreateResponse = VaultProviderCreateResponses[keyof VaultProviderCreateResponses];
export type VaultProviderUpdateData = {
    body: {
        vaultProviderId: string;
        name: string;
        config: {
            providerType: "hashicorp";
            url: string;
            token: string;
            namespace?: string;
            mount?: string;
        } | {
            providerType: "infisical";
            siteUrl?: string;
            clientId: string;
            clientSecret: string;
            projectId: string;
            environmentSlug: string;
            secretPath?: string;
        } | {
            providerType: "aws";
            region: string;
            accessKeyId: string;
            secretAccessKey: string;
            endpoint?: string;
        } | {
            providerType: "aws-parameter-store";
            region: string;
            accessKeyId: string;
            secretAccessKey: string;
            endpoint?: string;
            parameterPath?: string;
        } | {
            providerType: "doppler";
            serviceToken: string;
            project?: string;
            config?: string;
        } | {
            providerType: "azure";
            vaultUri: string;
            tenantId: string;
            clientId: string;
            clientSecret: string;
        } | {
            providerType: "scaleway";
            region?: string;
            projectId: string;
            secretKey: string;
            apiUrl?: string;
        } | {
            providerType: "phase";
            token: string;
            appId: string;
            env: string;
            path?: string;
            apiUrl?: string;
        };
        assignments: Array<{
            projectId: string;
            environmentIds?: Array<string>;
        }>;
    };
    path?: never;
    query?: never;
    url: "/vaultProvider.update";
};
export type VaultProviderUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type VaultProviderUpdateError = VaultProviderUpdateErrors[keyof VaultProviderUpdateErrors];
export type VaultProviderUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type VaultProviderUpdateResponse = VaultProviderUpdateResponses[keyof VaultProviderUpdateResponses];
export type VaultProviderRemoveData = {
    body: {
        vaultProviderId: string;
    };
    path?: never;
    query?: never;
    url: "/vaultProvider.remove";
};
export type VaultProviderRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type VaultProviderRemoveError = VaultProviderRemoveErrors[keyof VaultProviderRemoveErrors];
export type VaultProviderRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type VaultProviderRemoveResponse = VaultProviderRemoveResponses[keyof VaultProviderRemoveResponses];
export type VaultProviderAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/vaultProvider.all";
};
export type VaultProviderAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type VaultProviderAllError = VaultProviderAllErrors[keyof VaultProviderAllErrors];
export type VaultProviderAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type VaultProviderAllResponse = VaultProviderAllResponses[keyof VaultProviderAllResponses];
export type VaultProviderOneData = {
    body?: never;
    path?: never;
    query: {
        vaultProviderId: string;
    };
    url: "/vaultProvider.one";
};
export type VaultProviderOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type VaultProviderOneError = VaultProviderOneErrors[keyof VaultProviderOneErrors];
export type VaultProviderOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type VaultProviderOneResponse = VaultProviderOneResponses[keyof VaultProviderOneResponses];
export type VaultProviderTestConnectionData = {
    body: {
        vaultProviderId?: string;
        config?: {
            providerType: "hashicorp";
            url: string;
            token: string;
            namespace?: string;
            mount?: string;
        } | {
            providerType: "infisical";
            siteUrl?: string;
            clientId: string;
            clientSecret: string;
            projectId: string;
            environmentSlug: string;
            secretPath?: string;
        } | {
            providerType: "aws";
            region: string;
            accessKeyId: string;
            secretAccessKey: string;
            endpoint?: string;
        } | {
            providerType: "aws-parameter-store";
            region: string;
            accessKeyId: string;
            secretAccessKey: string;
            endpoint?: string;
            parameterPath?: string;
        } | {
            providerType: "doppler";
            serviceToken: string;
            project?: string;
            config?: string;
        } | {
            providerType: "azure";
            vaultUri: string;
            tenantId: string;
            clientId: string;
            clientSecret: string;
        } | {
            providerType: "scaleway";
            region?: string;
            projectId: string;
            secretKey: string;
            apiUrl?: string;
        } | {
            providerType: "phase";
            token: string;
            appId: string;
            env: string;
            path?: string;
            apiUrl?: string;
        };
    };
    path?: never;
    query?: never;
    url: "/vaultProvider.testConnection";
};
export type VaultProviderTestConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type VaultProviderTestConnectionError = VaultProviderTestConnectionErrors[keyof VaultProviderTestConnectionErrors];
export type VaultProviderTestConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type VaultProviderTestConnectionResponse = VaultProviderTestConnectionResponses[keyof VaultProviderTestConnectionResponses];
export type VaultProviderListSecretNamesData = {
    body?: never;
    path?: never;
    query: {
        vaultProviderId: string;
        projectId: string;
        environmentId?: string;
    };
    url: "/vaultProvider.listSecretNames";
};
export type VaultProviderListSecretNamesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type VaultProviderListSecretNamesError = VaultProviderListSecretNamesErrors[keyof VaultProviderListSecretNamesErrors];
export type VaultProviderListSecretNamesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type VaultProviderListSecretNamesResponse = VaultProviderListSecretNamesResponses[keyof VaultProviderListSecretNamesResponses];
export type AiOneData = {
    body?: never;
    path?: never;
    query: {
        aiId: string;
    };
    url: "/ai.one";
};
export type AiOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AiOneError = AiOneErrors[keyof AiOneErrors];
export type AiOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AiOneResponse = AiOneResponses[keyof AiOneResponses];
export type AiGetModelsData = {
    body?: never;
    path?: never;
    query: {
        apiUrl: string;
        apiKey: string;
    };
    url: "/ai.getModels";
};
export type AiGetModelsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AiGetModelsError = AiGetModelsErrors[keyof AiGetModelsErrors];
export type AiGetModelsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AiGetModelsResponse = AiGetModelsResponses[keyof AiGetModelsResponses];
export type AiCreateData = {
    body: {
        name: string;
        apiUrl: string;
        apiKey: string;
        model: string;
        isEnabled: boolean;
    };
    path?: never;
    query?: never;
    url: "/ai.create";
};
export type AiCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AiCreateError = AiCreateErrors[keyof AiCreateErrors];
export type AiCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AiCreateResponse = AiCreateResponses[keyof AiCreateResponses];
export type AiUpdateData = {
    body: {
        aiId: string;
        name?: string;
        apiUrl?: string;
        apiKey?: string;
        model?: string;
        isEnabled?: boolean;
        createdAt?: string;
    };
    path?: never;
    query?: never;
    url: "/ai.update";
};
export type AiUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AiUpdateError = AiUpdateErrors[keyof AiUpdateErrors];
export type AiUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AiUpdateResponse = AiUpdateResponses[keyof AiUpdateResponses];
export type AiGetAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/ai.getAll";
};
export type AiGetAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AiGetAllError = AiGetAllErrors[keyof AiGetAllErrors];
export type AiGetAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AiGetAllResponse = AiGetAllResponses[keyof AiGetAllResponses];
export type AiGetData = {
    body?: never;
    path?: never;
    query: {
        aiId: string;
    };
    url: "/ai.get";
};
export type AiGetErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AiGetError = AiGetErrors[keyof AiGetErrors];
export type AiGetResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AiGetResponse = AiGetResponses[keyof AiGetResponses];
export type AiDeleteData = {
    body: {
        aiId: string;
    };
    path?: never;
    query?: never;
    url: "/ai.delete";
};
export type AiDeleteErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AiDeleteError = AiDeleteErrors[keyof AiDeleteErrors];
export type AiDeleteResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AiDeleteResponse = AiDeleteResponses[keyof AiDeleteResponses];
export type AiGetCustomProvidersData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/ai.getCustomProviders";
};
export type AiGetCustomProvidersErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AiGetCustomProvidersError = AiGetCustomProvidersErrors[keyof AiGetCustomProvidersErrors];
export type AiGetCustomProvidersResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AiGetCustomProvidersResponse = AiGetCustomProvidersResponses[keyof AiGetCustomProvidersResponses];
export type AiSaveCustomProvidersData = {
    body: {
        providers: Array<{
            name: string;
            apiUrl: string;
        }>;
    };
    path?: never;
    query?: never;
    url: "/ai.saveCustomProviders";
};
export type AiSaveCustomProvidersErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AiSaveCustomProvidersError = AiSaveCustomProvidersErrors[keyof AiSaveCustomProvidersErrors];
export type AiSaveCustomProvidersResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AiSaveCustomProvidersResponse = AiSaveCustomProvidersResponses[keyof AiSaveCustomProvidersResponses];
export type AiGetEnabledProvidersData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/ai.getEnabledProviders";
};
export type AiGetEnabledProvidersErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AiGetEnabledProvidersError = AiGetEnabledProvidersErrors[keyof AiGetEnabledProvidersErrors];
export type AiGetEnabledProvidersResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AiGetEnabledProvidersResponse = AiGetEnabledProvidersResponses[keyof AiGetEnabledProvidersResponses];
export type AiAnalyzeLogsData = {
    body: {
        aiId: string;
        logs: string;
        context: "build" | "runtime";
    };
    path?: never;
    query?: never;
    url: "/ai.analyzeLogs";
};
export type AiAnalyzeLogsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AiAnalyzeLogsError = AiAnalyzeLogsErrors[keyof AiAnalyzeLogsErrors];
export type AiAnalyzeLogsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AiAnalyzeLogsResponse = AiAnalyzeLogsResponses[keyof AiAnalyzeLogsResponses];
export type AiTestConnectionData = {
    body: {
        apiUrl: string;
        apiKey: string;
        model: string;
    };
    path?: never;
    query?: never;
    url: "/ai.testConnection";
};
export type AiTestConnectionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AiTestConnectionError = AiTestConnectionErrors[keyof AiTestConnectionErrors];
export type AiTestConnectionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AiTestConnectionResponse = AiTestConnectionResponses[keyof AiTestConnectionResponses];
export type AiSuggestData = {
    body: {
        aiId: string;
        input: string;
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/ai.suggest";
};
export type AiSuggestErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AiSuggestError = AiSuggestErrors[keyof AiSuggestErrors];
export type AiSuggestResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AiSuggestResponse = AiSuggestResponses[keyof AiSuggestResponses];
export type AiDeployData = {
    body: {
        environmentId: string;
        id: string;
        dockerCompose: string;
        envVariables: string;
        serverId?: string;
        name: string;
        description: string;
        domains?: Array<{
            host: string;
            port: number;
            serviceName: string;
        }>;
        configFiles?: Array<{
            filePath: string;
            content: string;
        }>;
    };
    path?: never;
    query?: never;
    url: "/ai.deploy";
};
export type AiDeployErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AiDeployError = AiDeployErrors[keyof AiDeployErrors];
export type AiDeployResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AiDeployResponse = AiDeployResponses[keyof AiDeployResponses];
export type OrganizationCreateData = {
    body: {
        name: string;
        logo?: string;
    };
    path?: never;
    query?: never;
    url: "/organization.create";
};
export type OrganizationCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type OrganizationCreateError = OrganizationCreateErrors[keyof OrganizationCreateErrors];
export type OrganizationCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type OrganizationCreateResponse = OrganizationCreateResponses[keyof OrganizationCreateResponses];
export type OrganizationAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/organization.all";
};
export type OrganizationAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type OrganizationAllError = OrganizationAllErrors[keyof OrganizationAllErrors];
export type OrganizationAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type OrganizationAllResponse = OrganizationAllResponses[keyof OrganizationAllResponses];
export type OrganizationOneData = {
    body?: never;
    path?: never;
    query: {
        organizationId: string;
    };
    url: "/organization.one";
};
export type OrganizationOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type OrganizationOneError = OrganizationOneErrors[keyof OrganizationOneErrors];
export type OrganizationOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type OrganizationOneResponse = OrganizationOneResponses[keyof OrganizationOneResponses];
export type OrganizationUpdateData = {
    body: {
        organizationId: string;
        name: string;
        logo?: string;
        defaultRole?: string | null;
    };
    path?: never;
    query?: never;
    url: "/organization.update";
};
export type OrganizationUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type OrganizationUpdateError = OrganizationUpdateErrors[keyof OrganizationUpdateErrors];
export type OrganizationUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type OrganizationUpdateResponse = OrganizationUpdateResponses[keyof OrganizationUpdateResponses];
export type OrganizationDeleteData = {
    body: {
        organizationId: string;
    };
    path?: never;
    query?: never;
    url: "/organization.delete";
};
export type OrganizationDeleteErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type OrganizationDeleteError = OrganizationDeleteErrors[keyof OrganizationDeleteErrors];
export type OrganizationDeleteResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type OrganizationDeleteResponse = OrganizationDeleteResponses[keyof OrganizationDeleteResponses];
export type OrganizationInviteMemberData = {
    body: {
        email: string;
        role: string;
    };
    path?: never;
    query?: never;
    url: "/organization.inviteMember";
};
export type OrganizationInviteMemberErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type OrganizationInviteMemberError = OrganizationInviteMemberErrors[keyof OrganizationInviteMemberErrors];
export type OrganizationInviteMemberResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type OrganizationInviteMemberResponse = OrganizationInviteMemberResponses[keyof OrganizationInviteMemberResponses];
export type OrganizationAllInvitationsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/organization.allInvitations";
};
export type OrganizationAllInvitationsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type OrganizationAllInvitationsError = OrganizationAllInvitationsErrors[keyof OrganizationAllInvitationsErrors];
export type OrganizationAllInvitationsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type OrganizationAllInvitationsResponse = OrganizationAllInvitationsResponses[keyof OrganizationAllInvitationsResponses];
export type OrganizationRemoveInvitationData = {
    body: {
        invitationId: string;
    };
    path?: never;
    query?: never;
    url: "/organization.removeInvitation";
};
export type OrganizationRemoveInvitationErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type OrganizationRemoveInvitationError = OrganizationRemoveInvitationErrors[keyof OrganizationRemoveInvitationErrors];
export type OrganizationRemoveInvitationResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type OrganizationRemoveInvitationResponse = OrganizationRemoveInvitationResponses[keyof OrganizationRemoveInvitationResponses];
export type OrganizationUpdateMemberRoleData = {
    body: {
        memberId: string;
        role: string;
    };
    path?: never;
    query?: never;
    url: "/organization.updateMemberRole";
};
export type OrganizationUpdateMemberRoleErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type OrganizationUpdateMemberRoleError = OrganizationUpdateMemberRoleErrors[keyof OrganizationUpdateMemberRoleErrors];
export type OrganizationUpdateMemberRoleResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type OrganizationUpdateMemberRoleResponse = OrganizationUpdateMemberRoleResponses[keyof OrganizationUpdateMemberRoleResponses];
export type OrganizationSetDefaultData = {
    body: {
        organizationId: string;
    };
    path?: never;
    query?: never;
    url: "/organization.setDefault";
};
export type OrganizationSetDefaultErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type OrganizationSetDefaultError = OrganizationSetDefaultErrors[keyof OrganizationSetDefaultErrors];
export type OrganizationSetDefaultResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type OrganizationSetDefaultResponse = OrganizationSetDefaultResponses[keyof OrganizationSetDefaultResponses];
export type OrganizationActiveData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/organization.active";
};
export type OrganizationActiveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type OrganizationActiveError = OrganizationActiveErrors[keyof OrganizationActiveErrors];
export type OrganizationActiveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type OrganizationActiveResponse = OrganizationActiveResponses[keyof OrganizationActiveResponses];
export type LicenseKeyActivateData = {
    body: {
        licenseKey: string;
    };
    path?: never;
    query?: never;
    url: "/licenseKey.activate";
};
export type LicenseKeyActivateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LicenseKeyActivateError = LicenseKeyActivateErrors[keyof LicenseKeyActivateErrors];
export type LicenseKeyActivateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LicenseKeyActivateResponse = LicenseKeyActivateResponses[keyof LicenseKeyActivateResponses];
export type LicenseKeyValidateData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/licenseKey.validate";
};
export type LicenseKeyValidateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LicenseKeyValidateError = LicenseKeyValidateErrors[keyof LicenseKeyValidateErrors];
export type LicenseKeyValidateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LicenseKeyValidateResponse = LicenseKeyValidateResponses[keyof LicenseKeyValidateResponses];
export type LicenseKeyDeactivateData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/licenseKey.deactivate";
};
export type LicenseKeyDeactivateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LicenseKeyDeactivateError = LicenseKeyDeactivateErrors[keyof LicenseKeyDeactivateErrors];
export type LicenseKeyDeactivateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LicenseKeyDeactivateResponse = LicenseKeyDeactivateResponses[keyof LicenseKeyDeactivateResponses];
export type LicenseKeyGetEnterpriseSettingsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/licenseKey.getEnterpriseSettings";
};
export type LicenseKeyGetEnterpriseSettingsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LicenseKeyGetEnterpriseSettingsError = LicenseKeyGetEnterpriseSettingsErrors[keyof LicenseKeyGetEnterpriseSettingsErrors];
export type LicenseKeyGetEnterpriseSettingsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LicenseKeyGetEnterpriseSettingsResponse = LicenseKeyGetEnterpriseSettingsResponses[keyof LicenseKeyGetEnterpriseSettingsResponses];
export type LicenseKeyHaveValidLicenseKeyData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/licenseKey.haveValidLicenseKey";
};
export type LicenseKeyHaveValidLicenseKeyErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LicenseKeyHaveValidLicenseKeyError = LicenseKeyHaveValidLicenseKeyErrors[keyof LicenseKeyHaveValidLicenseKeyErrors];
export type LicenseKeyHaveValidLicenseKeyResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LicenseKeyHaveValidLicenseKeyResponse = LicenseKeyHaveValidLicenseKeyResponses[keyof LicenseKeyHaveValidLicenseKeyResponses];
export type LicenseKeyUpdateEnterpriseSettingsData = {
    body: {
        enableEnterpriseFeatures?: boolean;
    };
    path?: never;
    query?: never;
    url: "/licenseKey.updateEnterpriseSettings";
};
export type LicenseKeyUpdateEnterpriseSettingsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type LicenseKeyUpdateEnterpriseSettingsError = LicenseKeyUpdateEnterpriseSettingsErrors[keyof LicenseKeyUpdateEnterpriseSettingsErrors];
export type LicenseKeyUpdateEnterpriseSettingsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type LicenseKeyUpdateEnterpriseSettingsResponse = LicenseKeyUpdateEnterpriseSettingsResponses[keyof LicenseKeyUpdateEnterpriseSettingsResponses];
export type SsoShowSignInWithSsoData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/sso.showSignInWithSSO";
};
export type SsoShowSignInWithSsoErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SsoShowSignInWithSsoError = SsoShowSignInWithSsoErrors[keyof SsoShowSignInWithSsoErrors];
export type SsoShowSignInWithSsoResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SsoShowSignInWithSsoResponse = SsoShowSignInWithSsoResponses[keyof SsoShowSignInWithSsoResponses];
export type SsoEnforceSsoData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/sso.enforceSSO";
};
export type SsoEnforceSsoErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SsoEnforceSsoError = SsoEnforceSsoErrors[keyof SsoEnforceSsoErrors];
export type SsoEnforceSsoResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SsoEnforceSsoResponse = SsoEnforceSsoResponses[keyof SsoEnforceSsoResponses];
export type SsoListProvidersData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/sso.listProviders";
};
export type SsoListProvidersErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SsoListProvidersError = SsoListProvidersErrors[keyof SsoListProvidersErrors];
export type SsoListProvidersResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SsoListProvidersResponse = SsoListProvidersResponses[keyof SsoListProvidersResponses];
export type SsoGetTrustedOriginsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/sso.getTrustedOrigins";
};
export type SsoGetTrustedOriginsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SsoGetTrustedOriginsError = SsoGetTrustedOriginsErrors[keyof SsoGetTrustedOriginsErrors];
export type SsoGetTrustedOriginsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SsoGetTrustedOriginsResponse = SsoGetTrustedOriginsResponses[keyof SsoGetTrustedOriginsResponses];
export type SsoOneData = {
    body?: never;
    path?: never;
    query: {
        providerId: string;
    };
    url: "/sso.one";
};
export type SsoOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SsoOneError = SsoOneErrors[keyof SsoOneErrors];
export type SsoOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SsoOneResponse = SsoOneResponses[keyof SsoOneResponses];
export type SsoUpdateData = {
    body: {
        providerId: string;
        issuer: string;
        domains: Array<string>;
        oidcConfig?: {
            clientId: string;
            clientSecret: string;
            authorizationEndpoint?: string;
            tokenEndpoint?: string;
            userInfoEndpoint?: string;
            tokenEndpointAuthentication?: "client_secret_post" | "client_secret_basic";
            jwksEndpoint?: string;
            discoveryEndpoint?: string;
            skipDiscovery?: boolean;
            scopes?: Array<string>;
            pkce?: boolean;
            mapping?: {
                id: string;
                email: string;
                emailVerified?: string;
                name: string;
                image?: string;
                extraFields?: {
                    [key: string]: unknown;
                };
            };
        };
        samlConfig?: {
            entryPoint: string;
            cert: string;
            callbackUrl: string;
            audience?: string;
            idpMetadata?: {
                metadata?: string;
                entityID?: string;
                cert?: string;
                privateKey?: string;
                privateKeyPass?: string;
                isAssertionEncrypted?: boolean;
                encPrivateKey?: string;
                encPrivateKeyPass?: string;
                singleSignOnService?: Array<{
                    Binding: string;
                    Location: string;
                }>;
            };
            spMetadata: {
                metadata?: string;
                entityID?: string;
                binding?: string;
                privateKey?: string;
                privateKeyPass?: string;
                isAssertionEncrypted?: boolean;
                encPrivateKey?: string;
                encPrivateKeyPass?: string;
            };
            wantAssertionsSigned?: boolean;
            authnRequestsSigned?: boolean;
            signatureAlgorithm?: string;
            digestAlgorithm?: string;
            identifierFormat?: string;
            privateKey?: string;
            decryptionPvk?: string;
            additionalParams?: {
                [key: string]: unknown;
            };
            mapping?: {
                id: string;
                email: string;
                emailVerified?: string;
                name: string;
                firstName?: string;
                lastName?: string;
                extraFields?: {
                    [key: string]: unknown;
                };
            };
        };
        organizationId?: string;
        overrideUserInfo?: boolean;
    };
    path?: never;
    query?: never;
    url: "/sso.update";
};
export type SsoUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SsoUpdateError = SsoUpdateErrors[keyof SsoUpdateErrors];
export type SsoUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SsoUpdateResponse = SsoUpdateResponses[keyof SsoUpdateResponses];
export type SsoDeleteProviderData = {
    body: {
        providerId: string;
    };
    path?: never;
    query?: never;
    url: "/sso.deleteProvider";
};
export type SsoDeleteProviderErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SsoDeleteProviderError = SsoDeleteProviderErrors[keyof SsoDeleteProviderErrors];
export type SsoDeleteProviderResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SsoDeleteProviderResponse = SsoDeleteProviderResponses[keyof SsoDeleteProviderResponses];
export type SsoRegisterData = {
    body: {
        providerId: string;
        issuer: string;
        domains: Array<string>;
        oidcConfig?: {
            clientId: string;
            clientSecret: string;
            authorizationEndpoint?: string;
            tokenEndpoint?: string;
            userInfoEndpoint?: string;
            tokenEndpointAuthentication?: "client_secret_post" | "client_secret_basic";
            jwksEndpoint?: string;
            discoveryEndpoint?: string;
            skipDiscovery?: boolean;
            scopes?: Array<string>;
            pkce?: boolean;
            mapping?: {
                id: string;
                email: string;
                emailVerified?: string;
                name: string;
                image?: string;
                extraFields?: {
                    [key: string]: unknown;
                };
            };
        };
        samlConfig?: {
            entryPoint: string;
            cert: string;
            callbackUrl: string;
            audience?: string;
            idpMetadata?: {
                metadata?: string;
                entityID?: string;
                cert?: string;
                privateKey?: string;
                privateKeyPass?: string;
                isAssertionEncrypted?: boolean;
                encPrivateKey?: string;
                encPrivateKeyPass?: string;
                singleSignOnService?: Array<{
                    Binding: string;
                    Location: string;
                }>;
            };
            spMetadata: {
                metadata?: string;
                entityID?: string;
                binding?: string;
                privateKey?: string;
                privateKeyPass?: string;
                isAssertionEncrypted?: boolean;
                encPrivateKey?: string;
                encPrivateKeyPass?: string;
            };
            wantAssertionsSigned?: boolean;
            authnRequestsSigned?: boolean;
            signatureAlgorithm?: string;
            digestAlgorithm?: string;
            identifierFormat?: string;
            privateKey?: string;
            decryptionPvk?: string;
            additionalParams?: {
                [key: string]: unknown;
            };
            mapping?: {
                id: string;
                email: string;
                emailVerified?: string;
                name: string;
                firstName?: string;
                lastName?: string;
                extraFields?: {
                    [key: string]: unknown;
                };
            };
        };
        organizationId?: string;
        overrideUserInfo?: boolean;
    };
    path?: never;
    query?: never;
    url: "/sso.register";
};
export type SsoRegisterErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SsoRegisterError = SsoRegisterErrors[keyof SsoRegisterErrors];
export type SsoRegisterResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SsoRegisterResponse = SsoRegisterResponses[keyof SsoRegisterResponses];
export type SsoAddTrustedOriginData = {
    body: {
        origin: string;
    };
    path?: never;
    query?: never;
    url: "/sso.addTrustedOrigin";
};
export type SsoAddTrustedOriginErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SsoAddTrustedOriginError = SsoAddTrustedOriginErrors[keyof SsoAddTrustedOriginErrors];
export type SsoAddTrustedOriginResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SsoAddTrustedOriginResponse = SsoAddTrustedOriginResponses[keyof SsoAddTrustedOriginResponses];
export type SsoRemoveTrustedOriginData = {
    body: {
        origin: string;
    };
    path?: never;
    query?: never;
    url: "/sso.removeTrustedOrigin";
};
export type SsoRemoveTrustedOriginErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SsoRemoveTrustedOriginError = SsoRemoveTrustedOriginErrors[keyof SsoRemoveTrustedOriginErrors];
export type SsoRemoveTrustedOriginResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SsoRemoveTrustedOriginResponse = SsoRemoveTrustedOriginResponses[keyof SsoRemoveTrustedOriginResponses];
export type SsoUpdateTrustedOriginData = {
    body: {
        oldOrigin: string;
        newOrigin: string;
    };
    path?: never;
    query?: never;
    url: "/sso.updateTrustedOrigin";
};
export type SsoUpdateTrustedOriginErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type SsoUpdateTrustedOriginError = SsoUpdateTrustedOriginErrors[keyof SsoUpdateTrustedOriginErrors];
export type SsoUpdateTrustedOriginResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type SsoUpdateTrustedOriginResponse = SsoUpdateTrustedOriginResponses[keyof SsoUpdateTrustedOriginResponses];
export type ScimListProvidersData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/scim.listProviders";
};
export type ScimListProvidersErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ScimListProvidersError = ScimListProvidersErrors[keyof ScimListProvidersErrors];
export type ScimListProvidersResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ScimListProvidersResponse = ScimListProvidersResponses[keyof ScimListProvidersResponses];
export type ScimGenerateTokenData = {
    body: {
        providerId: string;
    };
    path?: never;
    query?: never;
    url: "/scim.generateToken";
};
export type ScimGenerateTokenErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ScimGenerateTokenError = ScimGenerateTokenErrors[keyof ScimGenerateTokenErrors];
export type ScimGenerateTokenResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ScimGenerateTokenResponse = ScimGenerateTokenResponses[keyof ScimGenerateTokenResponses];
export type ScimDeleteProviderData = {
    body: {
        providerId: string;
    };
    path?: never;
    query?: never;
    url: "/scim.deleteProvider";
};
export type ScimDeleteProviderErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ScimDeleteProviderError = ScimDeleteProviderErrors[keyof ScimDeleteProviderErrors];
export type ScimDeleteProviderResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ScimDeleteProviderResponse = ScimDeleteProviderResponses[keyof ScimDeleteProviderResponses];
export type ForwardAuthGetAuthDomainData = {
    body?: never;
    path?: never;
    query: {
        serverId: string | null;
    };
    url: "/forwardAuth.getAuthDomain";
};
export type ForwardAuthGetAuthDomainErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ForwardAuthGetAuthDomainError = ForwardAuthGetAuthDomainErrors[keyof ForwardAuthGetAuthDomainErrors];
export type ForwardAuthGetAuthDomainResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ForwardAuthGetAuthDomainResponse = ForwardAuthGetAuthDomainResponses[keyof ForwardAuthGetAuthDomainResponses];
export type ForwardAuthSetAuthDomainData = {
    body: {
        serverId: string | null;
        authDomain: string;
        https?: boolean;
        certificateType?: "none" | "letsencrypt" | "custom";
        customCertResolver?: string;
    };
    path?: never;
    query?: never;
    url: "/forwardAuth.setAuthDomain";
};
export type ForwardAuthSetAuthDomainErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ForwardAuthSetAuthDomainError = ForwardAuthSetAuthDomainErrors[keyof ForwardAuthSetAuthDomainErrors];
export type ForwardAuthSetAuthDomainResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ForwardAuthSetAuthDomainResponse = ForwardAuthSetAuthDomainResponses[keyof ForwardAuthSetAuthDomainResponses];
export type ForwardAuthRemoveAuthDomainData = {
    body: {
        serverId: string | null;
    };
    path?: never;
    query?: never;
    url: "/forwardAuth.removeAuthDomain";
};
export type ForwardAuthRemoveAuthDomainErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ForwardAuthRemoveAuthDomainError = ForwardAuthRemoveAuthDomainErrors[keyof ForwardAuthRemoveAuthDomainErrors];
export type ForwardAuthRemoveAuthDomainResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ForwardAuthRemoveAuthDomainResponse = ForwardAuthRemoveAuthDomainResponses[keyof ForwardAuthRemoveAuthDomainResponses];
export type ForwardAuthListProvidersData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/forwardAuth.listProviders";
};
export type ForwardAuthListProvidersErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ForwardAuthListProvidersError = ForwardAuthListProvidersErrors[keyof ForwardAuthListProvidersErrors];
export type ForwardAuthListProvidersResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ForwardAuthListProvidersResponse = ForwardAuthListProvidersResponses[keyof ForwardAuthListProvidersResponses];
export type ForwardAuthServerStatusData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/forwardAuth.serverStatus";
};
export type ForwardAuthServerStatusErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ForwardAuthServerStatusError = ForwardAuthServerStatusErrors[keyof ForwardAuthServerStatusErrors];
export type ForwardAuthServerStatusResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ForwardAuthServerStatusResponse = ForwardAuthServerStatusResponses[keyof ForwardAuthServerStatusResponses];
export type ForwardAuthDeployOnServerData = {
    body: {
        serverId: string | null;
        providerId: string;
    };
    path?: never;
    query?: never;
    url: "/forwardAuth.deployOnServer";
};
export type ForwardAuthDeployOnServerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ForwardAuthDeployOnServerError = ForwardAuthDeployOnServerErrors[keyof ForwardAuthDeployOnServerErrors];
export type ForwardAuthDeployOnServerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ForwardAuthDeployOnServerResponse = ForwardAuthDeployOnServerResponses[keyof ForwardAuthDeployOnServerResponses];
export type ForwardAuthRemoveOnServerData = {
    body: {
        serverId: string | null;
    };
    path?: never;
    query?: never;
    url: "/forwardAuth.removeOnServer";
};
export type ForwardAuthRemoveOnServerErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ForwardAuthRemoveOnServerError = ForwardAuthRemoveOnServerErrors[keyof ForwardAuthRemoveOnServerErrors];
export type ForwardAuthRemoveOnServerResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ForwardAuthRemoveOnServerResponse = ForwardAuthRemoveOnServerResponses[keyof ForwardAuthRemoveOnServerResponses];
export type ForwardAuthStatusData = {
    body?: never;
    path?: never;
    query: {
        domainId: string;
    };
    url: "/forwardAuth.status";
};
export type ForwardAuthStatusErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ForwardAuthStatusError = ForwardAuthStatusErrors[keyof ForwardAuthStatusErrors];
export type ForwardAuthStatusResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ForwardAuthStatusResponse = ForwardAuthStatusResponses[keyof ForwardAuthStatusResponses];
export type ForwardAuthEnableData = {
    body: {
        domainId: string;
    };
    path?: never;
    query?: never;
    url: "/forwardAuth.enable";
};
export type ForwardAuthEnableErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ForwardAuthEnableError = ForwardAuthEnableErrors[keyof ForwardAuthEnableErrors];
export type ForwardAuthEnableResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ForwardAuthEnableResponse = ForwardAuthEnableResponses[keyof ForwardAuthEnableResponses];
export type ForwardAuthDisableData = {
    body: {
        domainId: string;
    };
    path?: never;
    query?: never;
    url: "/forwardAuth.disable";
};
export type ForwardAuthDisableErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ForwardAuthDisableError = ForwardAuthDisableErrors[keyof ForwardAuthDisableErrors];
export type ForwardAuthDisableResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ForwardAuthDisableResponse = ForwardAuthDisableResponses[keyof ForwardAuthDisableResponses];
export type WhitelabelingGetData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/whitelabeling.get";
};
export type WhitelabelingGetErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type WhitelabelingGetError = WhitelabelingGetErrors[keyof WhitelabelingGetErrors];
export type WhitelabelingGetResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type WhitelabelingGetResponse = WhitelabelingGetResponses[keyof WhitelabelingGetResponses];
export type WhitelabelingUpdateData = {
    body: {
        whitelabelingConfig: {
            appName: string | null;
            appDescription: string | null;
            logoUrl: string | null;
            faviconUrl: string | null;
            customCss: string | null;
            loginLogoUrl: string | null;
            supportUrl: string | null;
            docsUrl: string | null;
            errorPageTitle: string | null;
            errorPageDescription: string | null;
            footerText: string | null;
            ogImageUrl: string | null;
        };
    };
    path?: never;
    query?: never;
    url: "/whitelabeling.update";
};
export type WhitelabelingUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type WhitelabelingUpdateError = WhitelabelingUpdateErrors[keyof WhitelabelingUpdateErrors];
export type WhitelabelingUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type WhitelabelingUpdateResponse = WhitelabelingUpdateResponses[keyof WhitelabelingUpdateResponses];
export type WhitelabelingResetData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/whitelabeling.reset";
};
export type WhitelabelingResetErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type WhitelabelingResetError = WhitelabelingResetErrors[keyof WhitelabelingResetErrors];
export type WhitelabelingResetResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type WhitelabelingResetResponse = WhitelabelingResetResponses[keyof WhitelabelingResetResponses];
export type WhitelabelingGetPublicData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/whitelabeling.getPublic";
};
export type WhitelabelingGetPublicErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type WhitelabelingGetPublicError = WhitelabelingGetPublicErrors[keyof WhitelabelingGetPublicErrors];
export type WhitelabelingGetPublicResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type WhitelabelingGetPublicResponse = WhitelabelingGetPublicResponses[keyof WhitelabelingGetPublicResponses];
export type CustomRoleAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/customRole.all";
};
export type CustomRoleAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type CustomRoleAllError = CustomRoleAllErrors[keyof CustomRoleAllErrors];
export type CustomRoleAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type CustomRoleAllResponse = CustomRoleAllResponses[keyof CustomRoleAllResponses];
export type CustomRoleCreateData = {
    body: {
        roleName: string;
        permissions: {
            [key: string]: Array<string>;
        };
    };
    path?: never;
    query?: never;
    url: "/customRole.create";
};
export type CustomRoleCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type CustomRoleCreateError = CustomRoleCreateErrors[keyof CustomRoleCreateErrors];
export type CustomRoleCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type CustomRoleCreateResponse = CustomRoleCreateResponses[keyof CustomRoleCreateResponses];
export type CustomRoleUpdateData = {
    body: {
        roleName: string;
        newRoleName?: string;
        permissions: {
            [key: string]: Array<string>;
        };
    };
    path?: never;
    query?: never;
    url: "/customRole.update";
};
export type CustomRoleUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type CustomRoleUpdateError = CustomRoleUpdateErrors[keyof CustomRoleUpdateErrors];
export type CustomRoleUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type CustomRoleUpdateResponse = CustomRoleUpdateResponses[keyof CustomRoleUpdateResponses];
export type CustomRoleRemoveData = {
    body: {
        roleName: string;
    };
    path?: never;
    query?: never;
    url: "/customRole.remove";
};
export type CustomRoleRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type CustomRoleRemoveError = CustomRoleRemoveErrors[keyof CustomRoleRemoveErrors];
export type CustomRoleRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type CustomRoleRemoveResponse = CustomRoleRemoveResponses[keyof CustomRoleRemoveResponses];
export type CustomRoleMembersByRoleData = {
    body?: never;
    path?: never;
    query: {
        roleName: string;
    };
    url: "/customRole.membersByRole";
};
export type CustomRoleMembersByRoleErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type CustomRoleMembersByRoleError = CustomRoleMembersByRoleErrors[keyof CustomRoleMembersByRoleErrors];
export type CustomRoleMembersByRoleResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type CustomRoleMembersByRoleResponse = CustomRoleMembersByRoleResponses[keyof CustomRoleMembersByRoleResponses];
export type CustomRoleGetStatementsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/customRole.getStatements";
};
export type CustomRoleGetStatementsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type CustomRoleGetStatementsError = CustomRoleGetStatementsErrors[keyof CustomRoleGetStatementsErrors];
export type CustomRoleGetStatementsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type CustomRoleGetStatementsResponse = CustomRoleGetStatementsResponses[keyof CustomRoleGetStatementsResponses];
export type AuditLogAllData = {
    body?: never;
    path?: never;
    query?: {
        userId?: string;
        userEmail?: string;
        resourceName?: string;
        action?: "create" | "update" | "delete" | "deploy" | "cancel" | "redeploy" | "login" | "logout";
        resourceType?: "project" | "service" | "environment" | "deployment" | "user" | "customRole" | "domain" | "certificate" | "registry" | "server" | "sshKey" | "gitProvider" | "notification" | "settings" | "session";
        from?: string;
        to?: string;
        limit?: number;
        offset?: number;
    };
    url: "/auditLog.all";
};
export type AuditLogAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type AuditLogAllError = AuditLogAllErrors[keyof AuditLogAllErrors];
export type AuditLogAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type AuditLogAllResponse = AuditLogAllResponses[keyof AuditLogAllResponses];
export type ScheduleCreateData = {
    body: {
        scheduleId?: string;
        name: string;
        description?: string | null;
        cronExpression: string;
        appName?: string;
        serviceName?: string | null;
        shellType?: "bash" | "sh";
        scheduleType?: "application" | "compose" | "server" | "dokploy-server";
        command: string;
        script?: string | null;
        applicationId?: string | null;
        composeId?: string | null;
        serverId?: string | null;
        organizationId?: string | null;
        enabled?: boolean;
        timezone?: string | null;
        createdAt?: string;
    };
    path?: never;
    query?: never;
    url: "/schedule.create";
};
export type ScheduleCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ScheduleCreateError = ScheduleCreateErrors[keyof ScheduleCreateErrors];
export type ScheduleCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ScheduleCreateResponse = ScheduleCreateResponses[keyof ScheduleCreateResponses];
export type ScheduleUpdateData = {
    body: {
        scheduleId: string;
        name: string;
        description?: string | null;
        cronExpression: string;
        appName?: string;
        serviceName?: string | null;
        shellType?: "bash" | "sh";
        scheduleType?: "application" | "compose" | "server" | "dokploy-server";
        command: string;
        script?: string | null;
        applicationId?: string | null;
        composeId?: string | null;
        serverId?: string | null;
        organizationId?: string | null;
        enabled?: boolean;
        timezone?: string | null;
        createdAt?: string;
    };
    path?: never;
    query?: never;
    url: "/schedule.update";
};
export type ScheduleUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ScheduleUpdateError = ScheduleUpdateErrors[keyof ScheduleUpdateErrors];
export type ScheduleUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ScheduleUpdateResponse = ScheduleUpdateResponses[keyof ScheduleUpdateResponses];
export type ScheduleDeleteData = {
    body: {
        scheduleId: string;
    };
    path?: never;
    query?: never;
    url: "/schedule.delete";
};
export type ScheduleDeleteErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ScheduleDeleteError = ScheduleDeleteErrors[keyof ScheduleDeleteErrors];
export type ScheduleDeleteResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ScheduleDeleteResponse = ScheduleDeleteResponses[keyof ScheduleDeleteResponses];
export type ScheduleListData = {
    body?: never;
    path?: never;
    query: {
        id: string;
        scheduleType: "application" | "compose" | "server" | "dokploy-server";
    };
    url: "/schedule.list";
};
export type ScheduleListErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ScheduleListError = ScheduleListErrors[keyof ScheduleListErrors];
export type ScheduleListResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ScheduleListResponse = ScheduleListResponses[keyof ScheduleListResponses];
export type ScheduleOneData = {
    body?: never;
    path?: never;
    query: {
        scheduleId: string;
    };
    url: "/schedule.one";
};
export type ScheduleOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ScheduleOneError = ScheduleOneErrors[keyof ScheduleOneErrors];
export type ScheduleOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ScheduleOneResponse = ScheduleOneResponses[keyof ScheduleOneResponses];
export type ScheduleRunManuallyData = {
    body: {
        scheduleId: string;
    };
    path?: never;
    query?: never;
    url: "/schedule.runManually";
};
export type ScheduleRunManuallyErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type ScheduleRunManuallyError = ScheduleRunManuallyErrors[keyof ScheduleRunManuallyErrors];
export type ScheduleRunManuallyResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type ScheduleRunManuallyResponse = ScheduleRunManuallyResponses[keyof ScheduleRunManuallyResponses];
export type RollbackDeleteData = {
    body: {
        rollbackId: string;
    };
    path?: never;
    query?: never;
    url: "/rollback.delete";
};
export type RollbackDeleteErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RollbackDeleteError = RollbackDeleteErrors[keyof RollbackDeleteErrors];
export type RollbackDeleteResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RollbackDeleteResponse = RollbackDeleteResponses[keyof RollbackDeleteResponses];
export type RollbackRollbackData = {
    body: {
        rollbackId: string;
    };
    path?: never;
    query?: never;
    url: "/rollback.rollback";
};
export type RollbackRollbackErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type RollbackRollbackError = RollbackRollbackErrors[keyof RollbackRollbackErrors];
export type RollbackRollbackResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type RollbackRollbackResponse = RollbackRollbackResponses[keyof RollbackRollbackResponses];
export type VolumeBackupsListData = {
    body?: never;
    path?: never;
    query: {
        id: string;
        volumeBackupType: "application" | "postgres" | "mysql" | "mariadb" | "mongo" | "redis" | "compose" | "libsql";
    };
    url: "/volumeBackups.list";
};
export type VolumeBackupsListErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type VolumeBackupsListError = VolumeBackupsListErrors[keyof VolumeBackupsListErrors];
export type VolumeBackupsListResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type VolumeBackupsListResponse = VolumeBackupsListResponses[keyof VolumeBackupsListResponses];
export type VolumeBackupsCreateData = {
    body: {
        name: string;
        volumeName: string;
        prefix: string;
        serviceType?: "application" | "postgres" | "mysql" | "mariadb" | "mongo" | "redis" | "compose" | "libsql";
        appName?: string;
        serviceName?: string | null;
        turnOff?: boolean;
        cronExpression: string;
        keepLatestCount?: number | null;
        enabled?: boolean | null;
        applicationId?: string | null;
        postgresId?: string | null;
        mariadbId?: string | null;
        mongoId?: string | null;
        mysqlId?: string | null;
        redisId?: string | null;
        libsqlId?: string | null;
        composeId?: string | null;
        createdAt?: string;
        destinationId: string;
    };
    path?: never;
    query?: never;
    url: "/volumeBackups.create";
};
export type VolumeBackupsCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type VolumeBackupsCreateError = VolumeBackupsCreateErrors[keyof VolumeBackupsCreateErrors];
export type VolumeBackupsCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type VolumeBackupsCreateResponse = VolumeBackupsCreateResponses[keyof VolumeBackupsCreateResponses];
export type VolumeBackupsOneData = {
    body?: never;
    path?: never;
    query: {
        volumeBackupId: string;
    };
    url: "/volumeBackups.one";
};
export type VolumeBackupsOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type VolumeBackupsOneError = VolumeBackupsOneErrors[keyof VolumeBackupsOneErrors];
export type VolumeBackupsOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type VolumeBackupsOneResponse = VolumeBackupsOneResponses[keyof VolumeBackupsOneResponses];
export type VolumeBackupsDeleteData = {
    body: {
        volumeBackupId: string;
    };
    path?: never;
    query?: never;
    url: "/volumeBackups.delete";
};
export type VolumeBackupsDeleteErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type VolumeBackupsDeleteError = VolumeBackupsDeleteErrors[keyof VolumeBackupsDeleteErrors];
export type VolumeBackupsDeleteResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type VolumeBackupsDeleteResponse = VolumeBackupsDeleteResponses[keyof VolumeBackupsDeleteResponses];
export type VolumeBackupsUpdateData = {
    body: {
        name: string;
        volumeName: string;
        prefix: string;
        serviceType?: "application" | "postgres" | "mysql" | "mariadb" | "mongo" | "redis" | "compose" | "libsql";
        appName?: string;
        serviceName?: string | null;
        turnOff?: boolean;
        cronExpression: string;
        keepLatestCount?: number | null;
        enabled?: boolean | null;
        applicationId?: string | null;
        postgresId?: string | null;
        mariadbId?: string | null;
        mongoId?: string | null;
        mysqlId?: string | null;
        redisId?: string | null;
        libsqlId?: string | null;
        composeId?: string | null;
        createdAt?: string;
        destinationId: string;
        volumeBackupId: string;
    };
    path?: never;
    query?: never;
    url: "/volumeBackups.update";
};
export type VolumeBackupsUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type VolumeBackupsUpdateError = VolumeBackupsUpdateErrors[keyof VolumeBackupsUpdateErrors];
export type VolumeBackupsUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type VolumeBackupsUpdateResponse = VolumeBackupsUpdateResponses[keyof VolumeBackupsUpdateResponses];
export type VolumeBackupsRunManuallyData = {
    body: {
        volumeBackupId: string;
    };
    path?: never;
    query?: never;
    url: "/volumeBackups.runManually";
};
export type VolumeBackupsRunManuallyErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type VolumeBackupsRunManuallyError = VolumeBackupsRunManuallyErrors[keyof VolumeBackupsRunManuallyErrors];
export type VolumeBackupsRunManuallyResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type VolumeBackupsRunManuallyResponse = VolumeBackupsRunManuallyResponses[keyof VolumeBackupsRunManuallyResponses];
export type EnvironmentCreateData = {
    body: {
        name: string;
        description?: string;
        projectId: string;
    };
    path?: never;
    query?: never;
    url: "/environment.create";
};
export type EnvironmentCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type EnvironmentCreateError = EnvironmentCreateErrors[keyof EnvironmentCreateErrors];
export type EnvironmentCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type EnvironmentCreateResponse = EnvironmentCreateResponses[keyof EnvironmentCreateResponses];
export type EnvironmentOneData = {
    body?: never;
    path?: never;
    query: {
        environmentId: string;
    };
    url: "/environment.one";
};
export type EnvironmentOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type EnvironmentOneError = EnvironmentOneErrors[keyof EnvironmentOneErrors];
export type EnvironmentOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type EnvironmentOneResponse = EnvironmentOneResponses[keyof EnvironmentOneResponses];
export type EnvironmentByProjectIdData = {
    body?: never;
    path?: never;
    query: {
        projectId: string;
    };
    url: "/environment.byProjectId";
};
export type EnvironmentByProjectIdErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type EnvironmentByProjectIdError = EnvironmentByProjectIdErrors[keyof EnvironmentByProjectIdErrors];
export type EnvironmentByProjectIdResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type EnvironmentByProjectIdResponse = EnvironmentByProjectIdResponses[keyof EnvironmentByProjectIdResponses];
export type EnvironmentRemoveData = {
    body: {
        environmentId: string;
    };
    path?: never;
    query?: never;
    url: "/environment.remove";
};
export type EnvironmentRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type EnvironmentRemoveError = EnvironmentRemoveErrors[keyof EnvironmentRemoveErrors];
export type EnvironmentRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type EnvironmentRemoveResponse = EnvironmentRemoveResponses[keyof EnvironmentRemoveResponses];
export type EnvironmentUpdateData = {
    body: {
        environmentId: string;
        name?: string;
        description?: string;
        projectId?: string;
        env?: string;
    };
    path?: never;
    query?: never;
    url: "/environment.update";
};
export type EnvironmentUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type EnvironmentUpdateError = EnvironmentUpdateErrors[keyof EnvironmentUpdateErrors];
export type EnvironmentUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type EnvironmentUpdateResponse = EnvironmentUpdateResponses[keyof EnvironmentUpdateResponses];
export type EnvironmentDuplicateData = {
    body: {
        environmentId: string;
        name: string;
        description?: string;
    };
    path?: never;
    query?: never;
    url: "/environment.duplicate";
};
export type EnvironmentDuplicateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type EnvironmentDuplicateError = EnvironmentDuplicateErrors[keyof EnvironmentDuplicateErrors];
export type EnvironmentDuplicateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type EnvironmentDuplicateResponse = EnvironmentDuplicateResponses[keyof EnvironmentDuplicateResponses];
export type EnvironmentSearchData = {
    body?: never;
    path?: never;
    query?: {
        q?: string;
        name?: string;
        description?: string;
        projectId?: string;
        limit?: number;
        offset?: number;
    };
    url: "/environment.search";
};
export type EnvironmentSearchErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type EnvironmentSearchError = EnvironmentSearchErrors[keyof EnvironmentSearchErrors];
export type EnvironmentSearchResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type EnvironmentSearchResponse = EnvironmentSearchResponses[keyof EnvironmentSearchResponses];
export type TagCreateData = {
    body: {
        name: string;
        color?: string | null;
    };
    path?: never;
    query?: never;
    url: "/tag.create";
};
export type TagCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type TagCreateError = TagCreateErrors[keyof TagCreateErrors];
export type TagCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type TagCreateResponse = TagCreateResponses[keyof TagCreateResponses];
export type TagAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/tag.all";
};
export type TagAllErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type TagAllError = TagAllErrors[keyof TagAllErrors];
export type TagAllResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type TagAllResponse = TagAllResponses[keyof TagAllResponses];
export type TagOneData = {
    body?: never;
    path?: never;
    query: {
        tagId: string;
    };
    url: "/tag.one";
};
export type TagOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type TagOneError = TagOneErrors[keyof TagOneErrors];
export type TagOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type TagOneResponse = TagOneResponses[keyof TagOneResponses];
export type TagUpdateData = {
    body: {
        tagId: string;
        name?: string;
        color?: string | null;
        createdAt?: string;
        organizationId?: string;
    };
    path?: never;
    query?: never;
    url: "/tag.update";
};
export type TagUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type TagUpdateError = TagUpdateErrors[keyof TagUpdateErrors];
export type TagUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type TagUpdateResponse = TagUpdateResponses[keyof TagUpdateResponses];
export type TagRemoveData = {
    body: {
        tagId: string;
    };
    path?: never;
    query?: never;
    url: "/tag.remove";
};
export type TagRemoveErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type TagRemoveError = TagRemoveErrors[keyof TagRemoveErrors];
export type TagRemoveResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type TagRemoveResponse = TagRemoveResponses[keyof TagRemoveResponses];
export type TagAssignToProjectData = {
    body: {
        projectId: string;
        tagId: string;
    };
    path?: never;
    query?: never;
    url: "/tag.assignToProject";
};
export type TagAssignToProjectErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type TagAssignToProjectError = TagAssignToProjectErrors[keyof TagAssignToProjectErrors];
export type TagAssignToProjectResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type TagAssignToProjectResponse = TagAssignToProjectResponses[keyof TagAssignToProjectResponses];
export type TagRemoveFromProjectData = {
    body: {
        projectId: string;
        tagId: string;
    };
    path?: never;
    query?: never;
    url: "/tag.removeFromProject";
};
export type TagRemoveFromProjectErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type TagRemoveFromProjectError = TagRemoveFromProjectErrors[keyof TagRemoveFromProjectErrors];
export type TagRemoveFromProjectResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type TagRemoveFromProjectResponse = TagRemoveFromProjectResponses[keyof TagRemoveFromProjectResponses];
export type TagBulkAssignData = {
    body: {
        projectId: string;
        tagIds: Array<string>;
    };
    path?: never;
    query?: never;
    url: "/tag.bulkAssign";
};
export type TagBulkAssignErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type TagBulkAssignError = TagBulkAssignErrors[keyof TagBulkAssignErrors];
export type TagBulkAssignResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type TagBulkAssignResponse = TagBulkAssignResponses[keyof TagBulkAssignResponses];
export type PatchCreateData = {
    body: {
        filePath: string;
        content: string;
        type?: "create" | "update" | "delete";
        enabled?: boolean;
        applicationId?: string | null;
        composeId?: string | null;
    };
    path?: never;
    query?: never;
    url: "/patch.create";
};
export type PatchCreateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PatchCreateError = PatchCreateErrors[keyof PatchCreateErrors];
export type PatchCreateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PatchCreateResponse = PatchCreateResponses[keyof PatchCreateResponses];
export type PatchOneData = {
    body?: never;
    path?: never;
    query: {
        patchId: string;
    };
    url: "/patch.one";
};
export type PatchOneErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PatchOneError = PatchOneErrors[keyof PatchOneErrors];
export type PatchOneResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PatchOneResponse = PatchOneResponses[keyof PatchOneResponses];
export type PatchByEntityIdData = {
    body?: never;
    path?: never;
    query: {
        id: string;
        type: "application" | "compose";
    };
    url: "/patch.byEntityId";
};
export type PatchByEntityIdErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PatchByEntityIdError = PatchByEntityIdErrors[keyof PatchByEntityIdErrors];
export type PatchByEntityIdResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PatchByEntityIdResponse = PatchByEntityIdResponses[keyof PatchByEntityIdResponses];
export type PatchUpdateData = {
    body: {
        patchId: string;
        type?: "create" | "update" | "delete";
        filePath?: string;
        enabled?: boolean;
        content?: string;
        createdAt?: string;
        updatedAt?: string | null;
    };
    path?: never;
    query?: never;
    url: "/patch.update";
};
export type PatchUpdateErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PatchUpdateError = PatchUpdateErrors[keyof PatchUpdateErrors];
export type PatchUpdateResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PatchUpdateResponse = PatchUpdateResponses[keyof PatchUpdateResponses];
export type PatchDeleteData = {
    body: {
        patchId: string;
    };
    path?: never;
    query?: never;
    url: "/patch.delete";
};
export type PatchDeleteErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PatchDeleteError = PatchDeleteErrors[keyof PatchDeleteErrors];
export type PatchDeleteResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PatchDeleteResponse = PatchDeleteResponses[keyof PatchDeleteResponses];
export type PatchToggleEnabledData = {
    body: {
        patchId: string;
        enabled: boolean;
    };
    path?: never;
    query?: never;
    url: "/patch.toggleEnabled";
};
export type PatchToggleEnabledErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PatchToggleEnabledError = PatchToggleEnabledErrors[keyof PatchToggleEnabledErrors];
export type PatchToggleEnabledResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PatchToggleEnabledResponse = PatchToggleEnabledResponses[keyof PatchToggleEnabledResponses];
export type PatchEnsureRepoData = {
    body: {
        id: string;
        type: "application" | "compose";
    };
    path?: never;
    query?: never;
    url: "/patch.ensureRepo";
};
export type PatchEnsureRepoErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PatchEnsureRepoError = PatchEnsureRepoErrors[keyof PatchEnsureRepoErrors];
export type PatchEnsureRepoResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PatchEnsureRepoResponse = PatchEnsureRepoResponses[keyof PatchEnsureRepoResponses];
export type PatchReadRepoDirectoriesData = {
    body?: never;
    path?: never;
    query: {
        id: string;
        type: "application" | "compose";
        repoPath: string;
    };
    url: "/patch.readRepoDirectories";
};
export type PatchReadRepoDirectoriesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PatchReadRepoDirectoriesError = PatchReadRepoDirectoriesErrors[keyof PatchReadRepoDirectoriesErrors];
export type PatchReadRepoDirectoriesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PatchReadRepoDirectoriesResponse = PatchReadRepoDirectoriesResponses[keyof PatchReadRepoDirectoriesResponses];
export type PatchReadRepoFileData = {
    body?: never;
    path?: never;
    query: {
        id: string;
        type: "application" | "compose";
        filePath: string;
    };
    url: "/patch.readRepoFile";
};
export type PatchReadRepoFileErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PatchReadRepoFileError = PatchReadRepoFileErrors[keyof PatchReadRepoFileErrors];
export type PatchReadRepoFileResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PatchReadRepoFileResponse = PatchReadRepoFileResponses[keyof PatchReadRepoFileResponses];
export type PatchSaveFileAsPatchData = {
    body: {
        id: string;
        type: "application" | "compose";
        filePath: string;
        content: string;
        patchType?: "create" | "update";
    };
    path?: never;
    query?: never;
    url: "/patch.saveFileAsPatch";
};
export type PatchSaveFileAsPatchErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PatchSaveFileAsPatchError = PatchSaveFileAsPatchErrors[keyof PatchSaveFileAsPatchErrors];
export type PatchSaveFileAsPatchResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PatchSaveFileAsPatchResponse = PatchSaveFileAsPatchResponses[keyof PatchSaveFileAsPatchResponses];
export type PatchMarkFileForDeletionData = {
    body: {
        id: string;
        type: "application" | "compose";
        filePath: string;
    };
    path?: never;
    query?: never;
    url: "/patch.markFileForDeletion";
};
export type PatchMarkFileForDeletionErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PatchMarkFileForDeletionError = PatchMarkFileForDeletionErrors[keyof PatchMarkFileForDeletionErrors];
export type PatchMarkFileForDeletionResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PatchMarkFileForDeletionResponse = PatchMarkFileForDeletionResponses[keyof PatchMarkFileForDeletionResponses];
export type PatchCleanPatchReposData = {
    body: {
        serverId?: string;
    };
    path?: never;
    query?: never;
    url: "/patch.cleanPatchRepos";
};
export type PatchCleanPatchReposErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type PatchCleanPatchReposError = PatchCleanPatchReposErrors[keyof PatchCleanPatchReposErrors];
export type PatchCleanPatchReposResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type PatchCleanPatchReposResponse = PatchCleanPatchReposResponses[keyof PatchCleanPatchReposResponses];
export type OverviewServicesData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/overview.services";
};
export type OverviewServicesErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type OverviewServicesError = OverviewServicesErrors[keyof OverviewServicesErrors];
export type OverviewServicesResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type OverviewServicesResponse = OverviewServicesResponses[keyof OverviewServicesResponses];
export type OverviewBackupsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/overview.backups";
};
export type OverviewBackupsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type OverviewBackupsError = OverviewBackupsErrors[keyof OverviewBackupsErrors];
export type OverviewBackupsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type OverviewBackupsResponse = OverviewBackupsResponses[keyof OverviewBackupsResponses];
export type OverviewDomainsData = {
    body?: never;
    path?: never;
    query?: never;
    url: "/overview.domains";
};
export type OverviewDomainsErrors = {
    /**
     * Invalid input data
     */
    400: ErrorBadRequest;
    /**
     * Authorization not provided
     */
    401: ErrorUnauthorized;
    /**
     * Insufficient access
     */
    403: ErrorForbidden;
    /**
     * Not found
     */
    404: ErrorNotFound;
    /**
     * Internal server error
     */
    500: ErrorInternalServerError;
};
export type OverviewDomainsError = OverviewDomainsErrors[keyof OverviewDomainsErrors];
export type OverviewDomainsResponses = {
    /**
     * Successful response
     */
    200: {
        [key: string]: never;
    };
};
export type OverviewDomainsResponse = OverviewDomainsResponses[keyof OverviewDomainsResponses];
//# sourceMappingURL=types.gen.d.ts.map