@mittwald/api-client 0.0.0-development-2f042ce-20260202 → 0.0.0-development-137cd36-20260225

package/dist/types/generated/v2/types.d.ts

@@ -298,6 +298,10 @@ export declare namespace MittwaldAPIV2 {
             type RequestData = InferredRequestData<typeof descriptors.containerRestartService>;
             type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.containerRestartService, TStatus>;
         }
+        namespace ContainerSetStackUpdateSchedule {
+            type RequestData = InferredRequestData<typeof descriptors.containerSetStackUpdateSchedule>;
+            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.containerSetStackUpdateSchedule, TStatus>;
+        }
         namespace ContainerStartService {
             type RequestData = InferredRequestData<typeof descriptors.containerStartService>;
             type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.containerStartService, TStatus>;
@@ -1726,14 +1730,6 @@ export declare namespace MittwaldAPIV2 {
             type RequestData = InferredRequestData<typeof descriptors.userUpdatePersonalizedSettings>;
             type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userUpdatePersonalizedSettings, TStatus>;
         }
-        namespace UserGetPollStatus {
-            type RequestData = InferredRequestData<typeof descriptors.userGetPollStatus>;
-            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userGetPollStatus, TStatus>;
-        }
-        namespace UserPostPollStatus {
-            type RequestData = InferredRequestData<typeof descriptors.userPostPollStatus>;
-            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userPostPollStatus, TStatus>;
-        }
         namespace UserGetSession {
             type RequestData = InferredRequestData<typeof descriptors.userGetSession>;
             type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userGetSession, TStatus>;
@@ -1830,6 +1826,10 @@ export declare namespace MittwaldAPIV2 {
             type RequestData = InferredRequestData<typeof descriptors.verificationVerifyCompany>;
             type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.verificationVerifyCompany, TStatus>;
         }
+        namespace ContractGetDetailOfContractByLicense {
+            type RequestData = InferredRequestData<typeof descriptors.contractGetDetailOfContractByLicense>;
+            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.contractGetDetailOfContractByLicense, TStatus>;
+        }
     }
     namespace Components {
         namespace Schemas {
@@ -1973,6 +1973,10 @@ export declare namespace MittwaldAPIV2 {
                 disabled: boolean;
                 id: string;
                 installationPath: string;
+                /**
+                 * The last error that occurred during an update. Resets on success.
+                 */
+                lastError?: string;
                 linkedDatabases: MittwaldAPIV2.Components.Schemas.AppLinkedDatabase[];
                 lockedBy?: {
                     [k: string]: MittwaldAPIV2.Components.Schemas.AppLockPurpose;
@@ -2491,15 +2495,21 @@ export declare namespace MittwaldAPIV2 {
             }
             interface ContainerServiceDeclareRequest {
                 /**
-                 * Defaults to image config on empty
+                 * The container command (equivalent to the [Docker cmd](https://docs.docker.com/reference/dockerfile/#cmd)). When omitted, this defaults to the command defined in the image.
+                 *
                  */
                 command?: string[];
                 deploy?: MittwaldAPIV2.Components.Schemas.ContainerDeploy;
                 description?: string;
                 /**
-                 * Defaults to image config on empty
+                 * The container entrypoint (equivalent to the [Docker entrypoint](https://docs.docker.com/reference/dockerfile/#entrypoint)). When omitted, this defaults to the entrypoint defined in the image.
+                 *
                  */
                 entrypoint?: string[];
+                /**
+                 * Key-value map of environment variables that should be passed into the container.
+                 *
+                 */
                 environment?: {
                     [k: string]: string;
                 };
@@ -2510,8 +2520,20 @@ export declare namespace MittwaldAPIV2 {
                 envs?: {
                     [k: string]: string;
                 };
+                /**
+                 * The image to run, in the usual format also used by `docker run` and `docker compose`. When the image is pulled from a private registry, make sure to create it first, using the `container-create-registry` endpoint. The appropriate registry is matched by hostname.
+                 *
+                 */
                 image: string;
+                /**
+                 * Exposed ports. Follows the format `<public-port>:<container-port>/<protocol>`. Exposed ports can be accessed from other containers (or managed apps) within the same project. To expose a port publicly, connect it with an ingress resource.
+                 *
+                 */
                 ports?: string[];
+                /**
+                 * Volume mounts for this container. These items always follow the format `<volume>:<mountpoint>`. The `<volume>` may either be a named volume, or a file path in the (always present) project file system (which is shared among containers and managed apps within a project).
+                 *
+                 */
                 volumes?: string[];
             }
             interface ContainerDeploy {
@@ -2519,15 +2541,21 @@ export declare namespace MittwaldAPIV2 {
             }
             interface ContainerServiceRequest {
                 /**
-                 * Defaults to image config on empty
+                 * The container command (equivalent to the [Docker cmd](https://docs.docker.com/reference/dockerfile/#cmd)). When omitted, this defaults to the command defined in the image.
+                 *
                  */
                 command?: string[];
                 deploy?: MittwaldAPIV2.Components.Schemas.ContainerDeploy;
                 description?: string;
                 /**
-                 * Defaults to image config on empty
+                 * The container entrypoint (equivalent to the [Docker entrypoint](https://docs.docker.com/reference/dockerfile/#entrypoint)). When omitted, this defaults to the entrypoint defined in the image.
+                 *
                  */
                 entrypoint?: string[];
+                /**
+                 * Key-value map of environment variables that should be passed into the container.
+                 *
+                 */
                 environment?: {
                     [k: string]: string;
                 };
@@ -2538,12 +2566,39 @@ export declare namespace MittwaldAPIV2 {
                 envs?: {
                     [k: string]: string;
                 };
+                /**
+                 * The image to run, in the usual format also used by `docker run` and `docker compose`. When the image is pulled from a private registry, make sure to create it first, using the `container-create-registry` endpoint. The appropriate registry is matched by hostname.
+                 *
+                 */
                 image?: string;
+                /**
+                 * Exposed ports. Follows the format `<public-port>:<container-port>/<protocol>`. Exposed ports can be accessed from other containers (or managed apps) within the same project. To expose a port publicly, connect it with an ingress resource.
+                 *
+                 */
                 ports?: string[];
+                /**
+                 * Volume mounts for this container. These items always follow the format `<volume>:<mountpoint>`. The `<volume>` may either be a named volume, or a file path in the (always present) project file system (which is shared among containers and managed apps within a project).
+                 *
+                 */
                 volumes?: string[];
             }
             interface ContainerResourceSpec {
+                /**
+                 * CPU limit for the container. The value can be specified as a decimal number, where `1` corresponds to
+                 * one full CPU core. For example, `0.5` means that the container is limited to using half of a CPU core.
+                 *
+                 */
                 cpus?: string;
+                /**
+                 * Memory limit for the container. The value can be specified in bytes or using a suffix to indicate
+                 * the unit.
+                 *
+                 * The format matches the one [used by Docker Compose](https://docs.docker.com/reference/compose-file/extension/#specifying-byte-values):
+                 *
+                 * > Values express a byte value as a string in `{amount}{byte unit}` format: The supported units are
+                 * `b` (bytes), `k` or `kb` (kilo bytes), `m` or `mb` (mega bytes) and `g` or `gb` (giga bytes).
+                 *
+                 */
                 memory?: string;
             }
             interface ContainerResources {
@@ -2554,25 +2609,61 @@ export declare namespace MittwaldAPIV2 {
                 deployedState: MittwaldAPIV2.Components.Schemas.ContainerServiceState;
                 description: string;
                 id: string;
+                /**
+                 * Message explaining the current state of the container. This may contain information about the current state of the container, or errors that occurred during deployment.
+                 *
+                 */
                 message?: string;
                 pendingState: MittwaldAPIV2.Components.Schemas.ContainerServiceState;
                 projectId: string;
                 requiresRecreate: boolean;
                 serviceName: string;
+                /**
+                 * A short ID of the container. This is a unique identifier for the container within the project, and can be used to reference it in other API calls, or for SSH connections.
+                 *
+                 */
                 shortId: string;
                 stackId: string;
                 status: MittwaldAPIV2.Components.Schemas.ContainerServiceStatus;
                 statusSetAt: string;
             }
             interface ContainerServiceState {
+                /**
+                 * The container command (equivalent to the [Docker cmd](https://docs.docker.com/reference/dockerfile/#cmd)). When omitted, this defaults to the command defined in the image.
+                 *
+                 */
                 command?: string[];
+                /**
+                 * The container entrypoint (equivalent to the [Docker entrypoint](https://docs.docker.com/reference/dockerfile/#entrypoint)). When omitted, this defaults to the entrypoint defined in the image.
+                 *
+                 */
                 entrypoint?: string[];
+                /**
+                 * Key-value map of environment variables that should be passed into the container.
+                 *
+                 */
                 envs?: {
                     [k: string]: string;
                 };
+                /**
+                 * The image to run, in the usual format also used by `docker run` and `docker compose`. When the image is pulled from a private registry, make sure to create it first, using the `container-create-registry` endpoint. The appropriate registry is matched by hostname.
+                 *
+                 */
                 image: string;
+                /**
+                 * The digest of the image that is currently deployed.
+                 *
+                 */
                 imageDigest?: string;
+                /**
+                 * Exposed ports. Follows the format `<public-port>:<container-port>/<protocol>`. Exposed ports can be accessed from other containers (or managed apps) within the same project. To expose a port publicly, connect it with an ingress resource.
+                 *
+                 */
                 ports?: string[];
+                /**
+                 * Volume mounts for this container. These items always follow the format `<volume>:<mountpoint>`. The `<volume>` may either be a named volume, or a file path in the (always present) project file system (which is shared among containers and managed apps within a project).
+                 *
+                 */
                 volumes?: string[];
             }
             type ContainerServiceStatus = "running" | "stopped" | "restarting" | "error" | "creating" | "starting";
@@ -2597,6 +2688,10 @@ export declare namespace MittwaldAPIV2 {
                 prefix: string;
                 projectId: string;
                 services?: MittwaldAPIV2.Components.Schemas.ContainerServiceResponse[];
+                updateSchedule?: {
+                    cron: string;
+                    timezone?: string;
+                } | null;
                 volumes?: MittwaldAPIV2.Components.Schemas.ContainerVolumeResponse[];
             }
             interface ContainerUpdateRegistry {
@@ -3125,21 +3220,56 @@ export declare namespace MittwaldAPIV2 {
             }
             interface DatabaseCreateMySqlDatabase {
                 characterSettings?: MittwaldAPIV2.Components.Schemas.DatabaseCharacterSettings;
+                /**
+                 * A description of the MySQLDatabase. This is for your own reference and has no effect on the database itself.
+                 *
+                 */
                 description: string;
                 projectId: string;
+                /**
+                 * The MySQL version to use for this database, in `<major>.<minor>` format. Use the `GET /v2/mysql-versions` endpoint to query available versions.
+                 *
+                 */
                 version: string;
             }
             interface DatabaseCreateMySqlUser {
+                /**
+                 * An IP range (in CIDR notation) for which access should be allowed.
+                 */
                 accessIpMask?: string;
+                /**
+                 * The access level that this MySQLUser should have for the database. The `full` access level grants the user read/write privileges on the database.
+                 *
+                 */
                 accessLevel: "full" | "readonly";
                 databaseId: string;
                 description: string;
+                /**
+                 * Describes if users should be able to connection to this database from external
+                 * sources. Defaults to `false` when not set.
+                 *
+                 * To find out how to connect to your database from external sources, refer to the `externalHostname` field of the `GET /v2/mysql-databases/{id}` endpoint.
+                 *
+                 */
                 externalAccess?: boolean;
                 password: string;
             }
             interface DatabaseCreateMySqlUserWithDatabase {
                 accessIpMask?: string;
+                /**
+                 * The access level that this MySQLUser should have for the database. The `full` access level grants the user read/write privileges on the database.
+                 *
+                 * For MySQLUsers that are created in the same step as the database itself, `full` is the only available option.
+                 *
+                 */
                 accessLevel: "full";
+                /**
+                 * Describes if users should be able to connection to this database from external
+                 * sources. Defaults to `false` when not set.
+                 *
+                 * To find out how to connect to your database from external sources, refer to the `externalHostname` field of the `GET /v2/mysql-databases/{id}` endpoint.
+                 *
+                 */
                 externalAccess?: boolean;
                 password: string;
             }
@@ -3151,20 +3281,46 @@ export declare namespace MittwaldAPIV2 {
                 versionId: string;
             }
             interface DatabaseCharacterSettings {
+                /**
+                 * A valid MySQL character set. Refer to https://dev.mysql.com/doc/refman/8.4/en/charset-mysql.html for more information and available character sets.
+                 *
+                 */
                 characterSet: string;
+                /**
+                 * A valid MySQL collation. Refer to https://dev.mysql.com/doc/refman/8.4/en/charset-mysql.html for more information and available collations.
+                 *
+                 */
                 collation: string;
             }
             interface DatabaseMySqlDatabase {
                 characterSettings: MittwaldAPIV2.Components.Schemas.DatabaseCharacterSettings;
                 createdAt: string;
+                /**
+                 * A description of the MySQLDatabase. This is for your own reference and has no effect on the database itself.
+                 *
+                 */
                 description: string;
+                /**
+                 * The hostname that you can use to connect to this MySQLDatabase from external sources, like your local machine or services running outside the mittwald cloud platform.
+                 *
+                 * Note that you still need a database user with `externalAccess` enabled to connect via this hostname.
+                 *
+                 */
                 externalHostname: string;
                 finalizers?: string[];
+                /**
+                 * The hostname that you can use to connect to this MySQLDatabase from _within_ the hosting environment.
+                 *
+                 */
                 hostname: string;
                 id: string;
                 isReady: boolean;
                 isShared: boolean;
                 mainUser?: MittwaldAPIV2.Components.Schemas.DatabaseMySqlUser;
+                /**
+                 * The name of the MySQLDatabase. This is also the name of the database that you can use when connecting to it. It is automatically generated and cannot be changed.
+                 *
+                 */
                 name: string;
                 projectId: string;
                 status: MittwaldAPIV2.Components.Schemas.DatabaseDatabaseStatus;
@@ -3172,21 +3328,51 @@ export declare namespace MittwaldAPIV2 {
                 storageUsageInBytes: number;
                 storageUsageInBytesSetAt: string;
                 updatedAt: string;
+                /**
+                 * The MySQL version that this database is running, in `<major>.<minor>` format. Use the `GET /v2/mysql-versions` endpoint to query available versions.
+                 *
+                 */
                 version: string;
             }
             interface DatabasePhpMyAdminURL {
                 url: string;
             }
             interface DatabaseMySqlUser {
+                /**
+                 * An IP range (in CIDR notation) for which access should be allowed.
+                 */
                 accessIpMask?: string;
+                /**
+                 * The access level that this MySQLUser should have for the database. The `full` access level grants
+                 * the user read/write privileges on the database.
+                 *
+                 */
                 accessLevel: "full" | "readonly";
                 createdAt: string;
                 databaseId: string;
                 description?: string;
                 disabled: boolean;
+                /**
+                 * Describes if users should be able to connection to this database from external sources.
+                 * Defaults to `false` when not set.
+                 *
+                 * To find out how to connect to your database from external sources, refer to the `externalHostname`
+                 * field of the `GET /v2/mysql-databases/{id}` endpoint.
+                 *
+                 */
                 externalAccess: boolean;
                 id: string;
+                /**
+                 * Indicates whether this MySQL user is the main user of the database. The main user is created by
+                 * default when a new MySQL database is provisioned. It can neither be deleted nor disabled,
+                 * but its password can be updated.
+                 *
+                 */
                 mainUser: boolean;
+                /**
+                 * The name of the MySQL user. This can be used as the username when connecting to the database.
+                 *
+                 */
                 name: string;
                 passwordUpdatedAt: string;
                 status: MittwaldAPIV2.Components.Schemas.DatabaseDatabaseUserStatus;
@@ -4036,6 +4222,23 @@ export declare namespace MittwaldAPIV2 {
                 projectId: string;
                 tls: MittwaldAPIV2.Components.Schemas.IngressTlsAcmeDeprecated | MittwaldAPIV2.Components.Schemas.IngressTlsCertificate;
             }
+            interface IngressListIngressesCompatibleWithCertificateIDRequest {
+                /**
+                 * The certificates UUID.
+                 */
+                certificateId: string;
+            }
+            interface IngressListIngressesCompatibleWithCertificateRequest {
+                /**
+                 * PEM-encoded certificate. Linebreaks have to be escaped with
+                 * .
+                 */
+                certificate: string;
+                /**
+                 * The projects UUID.
+                 */
+                projectId: string;
+            }
             interface IngressOwnership {
                 txtRecord?: string;
                 /**
@@ -4651,7 +4854,7 @@ export declare namespace MittwaldAPIV2 {
             type MembershipCustomerInheritedRoles = "notset" | "owner" | "member" | "accountant";
             interface MembershipCustomerInvite {
                 /**
-                 * Reference to the Project's avatar.
+                 * Reference to the Customer's avatar.
                  */
                 avatarRefId?: string;
                 /**
@@ -4738,10 +4941,6 @@ export declare namespace MittwaldAPIV2 {
                  * ID of the user that created the invite.
                  */
                 invitedBy: string;
-                /**
-                 * ID of the user this invite is for.
-                 */
-                userId?: string;
             }
             interface MembershipProjectInvite {
                 /**
@@ -4950,29 +5149,6 @@ export declare namespace MittwaldAPIV2 {
                 reservationLimit: number;
                 unlockLimit: number;
             }
-            type OrderLicenseOrderPreview = {
-                /**
-                 * Describe for which typo3 instance the license will be used.
-                 */
-                description?: string;
-                licenseType: "typo3";
-                /**
-                 * The major version for which a license should be purchased.
-                 */
-                majorVersion: number;
-            };
-            type OrderLicenseOrder = {
-                /**
-                 * Describe for which typo3 instance the license will be used.
-                 */
-                description: string;
-                licenseType: "typo3";
-                /**
-                 * The major version for which a license should be purchased.
-                 */
-                majorVersion: number;
-                projectId: string;
-            };
             interface OrderMachineTypeSpec {
                 machineType?: string;
             }
@@ -5022,9 +5198,6 @@ export declare namespace MittwaldAPIV2 {
             interface OrderLeadFyndrOrderPreviewResponse {
                 totalPrice: number;
             }
-            interface OrderLicenseOrderPreviewResponse {
-                totalPrice: number;
-            }
             interface OrderDomainOrderPreviewResponse {
                 /**
                  * Contract duration in months.
@@ -5292,7 +5465,7 @@ export declare namespace MittwaldAPIV2 {
                 webStorageUsageInBytesSetAt: string;
             }
             type ProjectServerDisableReason = "suspended";
-            type ProjectServerStatus = "pending" | "ready" | "unready" | "suspended";
+            type ProjectServerStatus = "pending" | "ready" | "unready" | "suspended" | "migrating";
             interface ProjectServer {
                 clusterName: string;
                 createdAt: string;
@@ -5789,6 +5962,32 @@ export declare namespace MittwaldAPIV2 {
             }
             type VerificationEmailOrigin = "IS_MITTWALD" | "IS_NOT_MITTWALD" | "COULD_BE_MITTWALD";
             type ContainerVolumeSortOrder = "nameAsc" | "nameDesc" | "storageAsc" | "storageDesc";
+            type OrderLicenseOrderPreview = {
+                /**
+                 * Describe for which typo3 instance the license will be used.
+                 */
+                description?: string;
+                licenseType: "typo3";
+                /**
+                 * The major version for which a license should be purchased.
+                 */
+                majorVersion: number;
+            };
+            interface OrderLicenseOrderPreviewResponse {
+                totalPrice: number;
+            }
+            type OrderLicenseOrder = {
+                /**
+                 * Describe for which typo3 instance the license will be used.
+                 */
+                description: string;
+                licenseType: "typo3";
+                /**
+                 * The major version for which a license should be purchased.
+                 */
+                majorVersion: number;
+                projectId: string;
+            };
             interface CommonsAddress {
                 street: string;
                 houseNumber: string;
@@ -5923,19 +6122,6 @@ export declare namespace MittwaldAPIV2 {
                     name?: "NoAccessTokenProvided";
                 };
             }
-            namespace SignupRemovingLastOwnerNotAllowedError {
-                interface ApplicationJson {
-                    /**
-                     * A json object, given further information about the error
-                     */
-                    info?: {};
-                    /**
-                     * more information about the error
-                     */
-                    message: string;
-                    name: "RemovingLastOwnerNotAllowedError";
-                }
-            }
             namespace SignupSecondFactorRequiredError {
                 type ApplicationJson = MittwaldAPIV2.Components.Schemas.SignupDomainError & {
                     name: "SecondFactorRequired";
@@ -6784,6 +6970,13 @@ export declare namespace MittwaldAPIV2 {
                             type Empty = unknown;
                         }
                     }
+                    namespace $400 {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
                     namespace $404 {
                         namespace Content {
                             interface ApplicationJson {
@@ -6791,6 +6984,13 @@ export declare namespace MittwaldAPIV2 {
                             }
                         }
                     }
+                    namespace $412 {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
                     namespace $429 {
                         namespace Content {
                             interface ApplicationJson {
@@ -7406,6 +7606,7 @@ export declare namespace MittwaldAPIV2 {
                     };
                     type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
                     type Query = {
+                        versionRange?: string;
                         recommended?: boolean;
                     };
                 }
@@ -8810,11 +9011,24 @@ export declare namespace MittwaldAPIV2 {
                         stackId: string;
                     };
                     interface RequestBody {
+                        /**
+                         * A set of containers that should be started in this stack. The key is relevant for
+                         * network connectivity between containers, because you can use it as DNS name to
+                         * resolve this containers from other containers running in the same project (or from
+                         * managed apps running in the same project).
+                         *
+                         * To **delete** an existing container from a stack using a `PUT` request, simply omit
+                         * it from the request body. Using a `PATCH` request, set it to an empty object `{}`.
+                         *
+                         */
                         services?: {
                             [k: string]: MittwaldAPIV2.Components.Schemas.ContainerServiceDeclareRequest;
                         };
                         /**
-                         * Volumes belonging to a Stack. Removing results in a detach, delete must be explicit.
+                         * A set of named volumes that should be created for this stack. Removing a volume
+                         * from this set will not delete the volume (for safety), but only detach it from the
+                         * stack. To delete a volume, use the `DELETE /stacks/{stackId}/volumes/{volumeId}` endpoint.
+                         *
                          */
                         volumes?: {
                             [k: string]: MittwaldAPIV2.Components.Schemas.ContainerVolumeDeclareRequest;
@@ -9901,6 +10115,82 @@ export declare namespace MittwaldAPIV2 {
                 }
             }
         }
+        namespace V2StacksStackIdUpdateSchedule {
+            namespace Put {
+                namespace Parameters {
+                    type Path = {
+                        stackId: string;
+                    };
+                    interface RequestBody {
+                        updateSchedule?: {
+                            cron: string;
+                            /**
+                             * Valid timezones can be retrieved via GET /v2/time-zones
+                             */
+                            timezone?: string;
+                        };
+                    }
+                    type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
+                    type Query = {};
+                }
+                namespace Responses {
+                    namespace $204 {
+                        namespace Content {
+                            type Empty = unknown;
+                        }
+                    }
+                    namespace $400 {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
+                    namespace $403 {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
+                    namespace $404 {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
+                    namespace $412 {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
+                    namespace $429 {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
+                    namespace $500 {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
+                    namespace Default {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
+                }
+            }
+        }
         namespace V2StacksStackIdServicesServiceIdActionsStart {
             namespace Post {
                 namespace Parameters {
@@ -11405,6 +11695,13 @@ export declare namespace MittwaldAPIV2 {
                             }
                         }
                     }
+                    namespace $403 {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
                     namespace $404 {
                         namespace Content {
                             interface ApplicationJson {
@@ -16192,6 +16489,13 @@ export declare namespace MittwaldAPIV2 {
                             }
                         }
                     }
+                    namespace $409 {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
                     namespace $429 {
                         namespace Content {
                             interface ApplicationJson {
@@ -17101,6 +17405,10 @@ export declare namespace MittwaldAPIV2 {
                         contact: "owner";
                     };
                     interface RequestBody {
+                        /**
+                         * Whether to avoid the email confirmation if possible. If set to true, a transfer lock of 60 days might be applied to the domain.
+                         */
+                        avoidEmailConfirmation?: boolean;
                         /**
                          * @minItems 1
                          */
@@ -20113,17 +20421,7 @@ export declare namespace MittwaldAPIV2 {
             namespace Post {
                 namespace Parameters {
                     type Path = {};
-                    interface RequestBody {
-                        /**
-                         * PEM-encoded certificate. Linebreaks have to be escaped with
-                         * .
-                         */
-                        certificate: string;
-                        /**
-                         * The projects UUID.
-                         */
-                        projectId: string;
-                    }
+                    type RequestBody = MittwaldAPIV2.Components.Schemas.IngressListIngressesCompatibleWithCertificateRequest | MittwaldAPIV2.Components.Schemas.IngressListIngressesCompatibleWithCertificateIDRequest;
                     type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
                     type Query = {
                         limit?: number;
@@ -28071,100 +28369,6 @@ export declare namespace MittwaldAPIV2 {
                 }
             }
         }
-        namespace V2PollSettingsUserId {
-            namespace Get {
-                namespace Parameters {
-                    type Path = {
-                        userId: string;
-                    };
-                    type Header = {};
-                    type Query = {};
-                }
-                namespace Responses {
-                    namespace $200 {
-                        namespace Content {
-                            type ApplicationJson = MittwaldAPIV2.Components.Schemas.PollUserPollSettings;
-                        }
-                    }
-                    namespace $400 {
-                        namespace Content {
-                            interface ApplicationJson {
-                                [k: string]: unknown;
-                            }
-                        }
-                    }
-                    namespace $404 {
-                        namespace Content {
-                            interface ApplicationJson {
-                                [k: string]: unknown;
-                            }
-                        }
-                    }
-                    namespace $429 {
-                        namespace Content {
-                            interface ApplicationJson {
-                                [k: string]: unknown;
-                            }
-                        }
-                    }
-                    namespace Default {
-                        namespace Content {
-                            interface ApplicationJson {
-                                [k: string]: unknown;
-                            }
-                        }
-                    }
-                }
-            }
-            namespace Post {
-                namespace Parameters {
-                    type Path = {
-                        userId: string;
-                    };
-                    interface RequestBody {
-                        status: "completed" | "muted" | "ignored";
-                        userId: string;
-                    }
-                    type Header = {};
-                    type Query = {};
-                }
-                namespace Responses {
-                    namespace $200 {
-                        namespace Content {
-                            type ApplicationJson = MittwaldAPIV2.Components.Schemas.PollUserPollSettings;
-                        }
-                    }
-                    namespace $400 {
-                        namespace Content {
-                            interface ApplicationJson {
-                                [k: string]: unknown;
-                            }
-                        }
-                    }
-                    namespace $403 {
-                        namespace Content {
-                            interface ApplicationJson {
-                                [k: string]: unknown;
-                            }
-                        }
-                    }
-                    namespace $429 {
-                        namespace Content {
-                            interface ApplicationJson {
-                                [k: string]: unknown;
-                            }
-                        }
-                    }
-                    namespace Default {
-                        namespace Content {
-                            interface ApplicationJson {
-                                [k: string]: unknown;
-                            }
-                        }
-                    }
-                }
-            }
-        }
         namespace V2UsersSelfSessionsTokenId {
             namespace Get {
                 namespace Parameters {
@@ -29208,11 +29412,6 @@ export declare namespace MittwaldAPIV2 {
                             }
                         }
                     }
-                    namespace $500 {
-                        namespace Content {
-                            type Empty = unknown;
-                        }
-                    }
                     namespace Default {
                         namespace Content {
                             interface ApplicationJson {
@@ -29253,9 +29452,50 @@ export declare namespace MittwaldAPIV2 {
                             }
                         }
                     }
-                    namespace $500 {
+                    namespace Default {
                         namespace Content {
-                            type Empty = unknown;
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        namespace V2LicensesLicenseIdContract {
+            namespace Get {
+                namespace Parameters {
+                    type Path = {
+                        licenseId: string;
+                    };
+                    type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
+                    type Query = {};
+                }
+                namespace Responses {
+                    namespace $200 {
+                        namespace Content {
+                            type ApplicationJson = MittwaldAPIV2.Components.Schemas.ContractContract;
+                        }
+                    }
+                    namespace $400 {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
+                    namespace $404 {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
+                    namespace $429 {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
                         }
                     }
                     namespace Default {