@mittwald/api-client 3.0.23 → 3.0.24

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

@@ -530,6 +530,10 @@ export declare module MittwaldAPIV2 {
             type RequestData = InferredRequestData<typeof descriptors.dnsZonesForProject>;
             type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsZonesForProject, TStatus>;
         }
+        namespace DomainUpdateDomainNameservers {
+            type RequestData = InferredRequestData<typeof descriptors.domainUpdateDomainNameservers>;
+            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainUpdateDomainNameservers, TStatus>;
+        }
         namespace DomainGetDomain {
             type RequestData = InferredRequestData<typeof descriptors.domainGetDomain>;
             type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainGetDomain, TStatus>;
@@ -542,6 +546,10 @@ export declare module MittwaldAPIV2 {
             type RequestData = InferredRequestData<typeof descriptors.domainGetScreenshotForDomain>;
             type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainGetScreenshotForDomain, TStatus>;
         }
+        namespace DomainGetDomainOwnership {
+            type RequestData = InferredRequestData<typeof descriptors.domainGetDomainOwnership>;
+            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainGetDomainOwnership, TStatus>;
+        }
         namespace DomainListDomainOwnerships {
             type RequestData = InferredRequestData<typeof descriptors.domainListDomainOwnerships>;
             type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainListDomainOwnerships, TStatus>;
@@ -554,10 +562,6 @@ export declare module MittwaldAPIV2 {
             type RequestData = InferredRequestData<typeof descriptors.domainResendDomainEmail>;
             type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainResendDomainEmail, TStatus>;
         }
-        namespace DomainGetSpecificDomainOwnership {
-            type RequestData = InferredRequestData<typeof descriptors.domainGetSpecificDomainOwnership>;
-            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainGetSpecificDomainOwnership, TStatus>;
-        }
         namespace DomainVerifyDomainOwnership {
             type RequestData = InferredRequestData<typeof descriptors.domainVerifyDomainOwnership>;
             type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainVerifyDomainOwnership, TStatus>;
@@ -1146,49 +1150,45 @@ export declare module MittwaldAPIV2 {
             type RequestData = InferredRequestData<typeof descriptors.userVerifyRegistration>;
             type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userVerifyRegistration, TStatus>;
         }
-        namespace DomainAbortDeclareProcess {
-            type RequestData = InferredRequestData<typeof descriptors.domainAbortDeclareProcess>;
-            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainAbortDeclareProcess, TStatus>;
+        namespace DomainAbortDomainDeclaration {
+            type RequestData = InferredRequestData<typeof descriptors.domainAbortDomainDeclaration>;
+            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainAbortDomainDeclaration, TStatus>;
         }
-        namespace DomainGetHandleFields {
-            type RequestData = InferredRequestData<typeof descriptors.domainGetHandleFields>;
-            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainGetHandleFields, TStatus>;
+        namespace DomainListTlds {
+            type RequestData = InferredRequestData<typeof descriptors.domainListTlds>;
+            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainListTlds, TStatus>;
         }
-        namespace DomainGetSupportedTlds {
-            type RequestData = InferredRequestData<typeof descriptors.domainGetSupportedTlds>;
-            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainGetSupportedTlds, TStatus>;
+        namespace DomainListTldContactSchemas {
+            type RequestData = InferredRequestData<typeof descriptors.domainListTldContactSchemas>;
+            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainListTldContactSchemas, TStatus>;
         }
-        namespace DomainCheckDomainAvailability {
-            type RequestData = InferredRequestData<typeof descriptors.domainCheckDomainAvailability>;
-            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainCheckDomainAvailability, TStatus>;
+        namespace DomainUpdateDomainAuthCode {
+            type RequestData = InferredRequestData<typeof descriptors.domainUpdateDomainAuthCode>;
+            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainUpdateDomainAuthCode, TStatus>;
         }
-        namespace DomainCreateAuthcodeForDomain {
-            type RequestData = InferredRequestData<typeof descriptors.domainCreateAuthcodeForDomain>;
-            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainCreateAuthcodeForDomain, TStatus>;
+        namespace DomainUpdateDomainContact {
+            type RequestData = InferredRequestData<typeof descriptors.domainUpdateDomainContact>;
+            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainUpdateDomainContact, TStatus>;
         }
-        namespace DomainCreateAuthcode2ForDomain {
-            type RequestData = InferredRequestData<typeof descriptors.domainCreateAuthcode2ForDomain>;
-            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainCreateAuthcode2ForDomain, TStatus>;
+        namespace DomainUpdateDomainProjectId {
+            type RequestData = InferredRequestData<typeof descriptors.domainUpdateDomainProjectId>;
+            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainUpdateDomainProjectId, TStatus>;
         }
-        namespace DomainDeclareProcessChangeAuthcode {
-            type RequestData = InferredRequestData<typeof descriptors.domainDeclareProcessChangeAuthcode>;
-            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainDeclareProcessChangeAuthcode, TStatus>;
+        namespace DomainCreateDomainAuthCode {
+            type RequestData = InferredRequestData<typeof descriptors.domainCreateDomainAuthCode>;
+            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainCreateDomainAuthCode, TStatus>;
         }
-        namespace DomainDeclareProcessChangeHandles {
-            type RequestData = InferredRequestData<typeof descriptors.domainDeclareProcessChangeHandles>;
-            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainDeclareProcessChangeHandles, TStatus>;
+        namespace DomainCreateDomainAuthCode2 {
+            type RequestData = InferredRequestData<typeof descriptors.domainCreateDomainAuthCode2>;
+            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainCreateDomainAuthCode2, TStatus>;
         }
-        namespace DomainChangeOwnercOfDomain {
-            type RequestData = InferredRequestData<typeof descriptors.domainChangeOwnercOfDomain>;
-            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainChangeOwnercOfDomain, TStatus>;
+        namespace DomainCheckDomainRegistrability {
+            type RequestData = InferredRequestData<typeof descriptors.domainCheckDomainRegistrability>;
+            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainCheckDomainRegistrability, TStatus>;
         }
-        namespace DomainChangeProjectOfDomain {
-            type RequestData = InferredRequestData<typeof descriptors.domainChangeProjectOfDomain>;
-            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainChangeProjectOfDomain, TStatus>;
-        }
-        namespace DomainDeclareNameservers {
-            type RequestData = InferredRequestData<typeof descriptors.domainDeclareNameservers>;
-            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainDeclareNameservers, TStatus>;
+        namespace DomainCheckDomainRegistrabilityV2Deprecated {
+            type RequestData = InferredRequestData<typeof descriptors.domainCheckDomainRegistrabilityV2Deprecated>;
+            type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainCheckDomainRegistrabilityV2Deprecated, TStatus>;
         }
     }
     namespace Components {
@@ -1575,6 +1575,7 @@ export declare module MittwaldAPIV2 {
                 articles: MittwaldAPIV2.Components.Schemas.ContractArticle[];
                 contractPeriod: number;
                 description: string;
+                freeTrialDays: number;
                 groupByProjectId?: string;
                 invoicingPeriod: number;
                 isActivated: boolean;
@@ -8227,6 +8228,57 @@ export declare module MittwaldAPIV2 {
                 }
             }
         }
+        namespace V2DomainsDomainIdHandlesOwnerc { }
+        namespace V2DomainsDomainIdProjectId { }
+        namespace V2DomainsDomainIdActionsCreateAuthcode { }
+        namespace V2DomainsDomainIdActionsCreateAuthcode2 { }
+        namespace V2DomainsDomainIdNameservers {
+            namespace Patch {
+                namespace Parameters {
+                    type Path = {
+                        domainId: string;
+                    };
+                    interface RequestBody {
+                        /**
+                         * @minItems 2
+                         */
+                        nameservers?: [string, string, ...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 $404 {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
+                    namespace Default {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        namespace V2DomainsDomainIdDeclarationsAuthcode { }
+        namespace V2DomainsDomainIdDeclarationsHandles { }
         namespace V2DomainsDomainId {
             namespace Get {
                 namespace Parameters {
@@ -8272,7 +8324,7 @@ export declare module MittwaldAPIV2 {
                     };
                     interface RequestBody {
                         /**
-                         * If true, Domain is in grace period.
+                         * Only for .de Domains.
                          */
                         transit?: boolean;
                     }
@@ -8349,11 +8401,11 @@ export declare module MittwaldAPIV2 {
                 }
             }
         }
-        namespace V2ProjectsProjectIdDomainOwnerships {
+        namespace V2DomainOwnershipsDomainOwnershipId {
             namespace Get {
                 namespace Parameters {
                     type Path = {
-                        projectId: string;
+                        domainOwnershipId: string;
                     };
                     type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
                     type Query = {};
@@ -8361,7 +8413,7 @@ export declare module MittwaldAPIV2 {
                 namespace Responses {
                     namespace $200 {
                         namespace Content {
-                            type ApplicationJson = MittwaldAPIV2.Components.Schemas.DomainDomainOwnership[];
+                            type ApplicationJson = MittwaldAPIV2.Components.Schemas.DomainDomainOwnership;
                         }
                     }
                     namespace $400 {
@@ -8371,6 +8423,13 @@ export declare module MittwaldAPIV2 {
                             }
                         }
                     }
+                    namespace $404 {
+                        namespace Content {
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
+                        }
+                    }
                     namespace Default {
                         namespace Content {
                             interface ApplicationJson {
@@ -8381,23 +8440,19 @@ export declare module MittwaldAPIV2 {
                 }
             }
         }
-        namespace V2ProjectsProjectIdDomains {
+        namespace V2ProjectsProjectIdDomainOwnerships {
             namespace Get {
                 namespace Parameters {
                     type Path = {
                         projectId: string;
                     };
                     type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
-                    type Query = {
-                        page?: number;
-                        limit?: number;
-                        domainSearchName?: string;
-                    };
+                    type Query = {};
                 }
                 namespace Responses {
                     namespace $200 {
                         namespace Content {
-                            type ApplicationJson = MittwaldAPIV2.Components.Schemas.DomainDomain[];
+                            type ApplicationJson = MittwaldAPIV2.Components.Schemas.DomainDomainOwnership[];
                         }
                     }
                     namespace $400 {
@@ -8417,22 +8472,23 @@ export declare module MittwaldAPIV2 {
                 }
             }
         }
-        namespace V2DomainsDomainIdActionsResendEmail {
-            namespace Post {
+        namespace V2ProjectsProjectIdDomains {
+            namespace Get {
                 namespace Parameters {
                     type Path = {
-                        domainId: string;
+                        projectId: string;
                     };
-                    interface RequestBody {
-                        [k: string]: unknown;
-                    }
                     type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
-                    type Query = {};
+                    type Query = {
+                        page?: number;
+                        limit?: number;
+                        domainSearchName?: string;
+                    };
                 }
                 namespace Responses {
-                    namespace $204 {
+                    namespace $200 {
                         namespace Content {
-                            type Empty = unknown;
+                            type ApplicationJson = MittwaldAPIV2.Components.Schemas.DomainDomain[];
                         }
                     }
                     namespace $400 {
@@ -8442,13 +8498,6 @@ export declare module MittwaldAPIV2 {
                             }
                         }
                     }
-                    namespace $404 {
-                        namespace Content {
-                            interface ApplicationJson {
-                                [k: string]: unknown;
-                            }
-                        }
-                    }
                     namespace Default {
                         namespace Content {
                             interface ApplicationJson {
@@ -8459,19 +8508,22 @@ export declare module MittwaldAPIV2 {
                 }
             }
         }
-        namespace V2DomainOwnershipsDomainOwnershipId {
-            namespace Get {
+        namespace V2DomainsDomainIdActionsResendEmail {
+            namespace Post {
                 namespace Parameters {
                     type Path = {
-                        domainOwnershipId: string;
+                        domainId: string;
                     };
+                    interface RequestBody {
+                        [k: string]: unknown;
+                    }
                     type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
                     type Query = {};
                 }
                 namespace Responses {
-                    namespace $200 {
+                    namespace $204 {
                         namespace Content {
-                            type ApplicationJson = MittwaldAPIV2.Components.Schemas.DomainDomainOwnership;
+                            type Empty = unknown;
                         }
                     }
                     namespace $400 {
@@ -8497,6 +8549,8 @@ export declare module MittwaldAPIV2 {
                     }
                 }
             }
+        }
+        namespace V2DomainOwnershipsDomainOwnershipIdActionsVerify {
             namespace Post {
                 namespace Parameters {
                     type Path = {
@@ -14530,7 +14584,8 @@ export declare module MittwaldAPIV2 {
                 }
             }
         }
-        namespace V2DomainsDomainIdDeclarations {
+        namespace V2DomainsDomainIdDeclarations { }
+        namespace V2DomainsDomainIdDeclaration {
             namespace Delete {
                 namespace Parameters {
                     type Path = {
@@ -14569,35 +14624,9 @@ export declare module MittwaldAPIV2 {
                 }
             }
         }
-        namespace V2DomainsHandleSchemaDomainName {
-            namespace Get {
-                namespace Parameters {
-                    type Path = {
-                        domainName: string;
-                    };
-                    type Header = {};
-                    type Query = {};
-                }
-                namespace Responses {
-                    namespace $200 {
-                        namespace Content {
-                            interface ApplicationJson {
-                                jsonSchemaAdminC?: {};
-                                jsonSchemaOwnerC: {};
-                            }
-                        }
-                    }
-                    namespace Default {
-                        namespace Content {
-                            interface ApplicationJson {
-                                [k: string]: unknown;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        namespace V2DomainsSupportedTlds {
+        namespace V2DomainsHandleSchemaDomainName { }
+        namespace V2DomainsSupportedTlds { }
+        namespace V2DomainTlds {
             namespace Get {
                 namespace Parameters {
                     type Path = {};
@@ -14620,13 +14649,12 @@ export declare module MittwaldAPIV2 {
                 }
             }
         }
-        namespace V2Domains {
-            namespace Post {
+        namespace V2DomainTldsTldContactSchemas {
+            namespace Get {
                 namespace Parameters {
-                    type Path = {};
-                    interface RequestBody {
-                        domain: string;
-                    }
+                    type Path = {
+                        tld: string;
+                    };
                     type Header = {};
                     type Query = {};
                 }
@@ -14634,14 +14662,8 @@ export declare module MittwaldAPIV2 {
                     namespace $200 {
                         namespace Content {
                             interface ApplicationJson {
-                                available: boolean;
-                            }
-                        }
-                    }
-                    namespace $400 {
-                        namespace Content {
-                            interface ApplicationJson {
-                                [k: string]: unknown;
+                                jsonSchemaAdminC?: {};
+                                jsonSchemaOwnerC: {};
                             }
                         }
                     }
@@ -14655,23 +14677,24 @@ export declare module MittwaldAPIV2 {
                 }
             }
         }
-        namespace V2DomainsDomainIdActionsCreateAuthcode {
-            namespace Post {
+        namespace V2DomainsDomainIdAuthcode { }
+        namespace V2DomainsDomainIdAuthCode {
+            namespace Patch {
                 namespace Parameters {
                     type Path = {
                         domainId: string;
                     };
                     interface RequestBody {
-                        [k: string]: unknown;
+                        authCode: string;
                     }
                     type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
                     type Query = {};
                 }
                 namespace Responses {
-                    namespace $201 {
+                    namespace $200 {
                         namespace Content {
                             interface ApplicationJson {
-                                authCode: string;
+                                [k: string]: unknown;
                             }
                         }
                     }
@@ -14699,22 +14722,31 @@ export declare module MittwaldAPIV2 {
                 }
             }
         }
-        namespace V2DomainsDomainIdActionsCreateAuthcode2 {
-            namespace Post {
+        namespace V2DomainsDomainIdContactsContact {
+            namespace Patch {
                 namespace Parameters {
                     type Path = {
                         domainId: string;
+                        contact: "owner";
                     };
                     interface RequestBody {
-                        [k: string]: unknown;
+                        /**
+                         * @minItems 1
+                         */
+                        contact: [
+                            MittwaldAPIV2.Components.Schemas.DomainHandleField,
+                            ...MittwaldAPIV2.Components.Schemas.DomainHandleField[]
+                        ];
                     }
                     type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
                     type Query = {};
                 }
                 namespace Responses {
-                    namespace $204 {
+                    namespace $200 {
                         namespace Content {
-                            type Empty = unknown;
+                            interface ApplicationJson {
+                                [k: string]: unknown;
+                            }
                         }
                     }
                     namespace $400 {
@@ -14741,24 +14773,22 @@ export declare module MittwaldAPIV2 {
                 }
             }
         }
-        namespace V2DomainsDomainIdDeclarationsAuthcode {
-            namespace Put {
+        namespace V2DomainsDomainIdProjectId {
+            namespace Patch {
                 namespace Parameters {
                     type Path = {
                         domainId: string;
                     };
                     interface RequestBody {
-                        authCode: string;
+                        projectId?: string;
                     }
                     type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
                     type Query = {};
                 }
                 namespace Responses {
-                    namespace $200 {
+                    namespace $204 {
                         namespace Content {
-                            interface ApplicationJson {
-                                [k: string]: unknown;
-                            }
+                            type Empty = unknown;
                         }
                     }
                     namespace $400 {
@@ -14785,29 +14815,23 @@ export declare module MittwaldAPIV2 {
                 }
             }
         }
-        namespace V2DomainsDomainIdDeclarationsHandles {
-            namespace Put {
+        namespace V2DomainsDomainIdActionsAuthCode {
+            namespace Post {
                 namespace Parameters {
                     type Path = {
                         domainId: string;
                     };
                     interface RequestBody {
-                        /**
-                         * @minItems 1
-                         */
-                        ownerC: [
-                            MittwaldAPIV2.Components.Schemas.DomainHandleField,
-                            ...MittwaldAPIV2.Components.Schemas.DomainHandleField[]
-                        ];
+                        [k: string]: unknown;
                     }
                     type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
                     type Query = {};
                 }
                 namespace Responses {
-                    namespace $200 {
+                    namespace $201 {
                         namespace Content {
                             interface ApplicationJson {
-                                [k: string]: unknown;
+                                authCode: string;
                             }
                         }
                     }
@@ -14835,30 +14859,22 @@ export declare module MittwaldAPIV2 {
                 }
             }
         }
-        namespace V2DomainsDomainIdHandlesOwnerc {
-            namespace Put {
+        namespace V2DomainsDomainIdActionsAuthCode2 {
+            namespace Post {
                 namespace Parameters {
                     type Path = {
                         domainId: string;
                     };
                     interface RequestBody {
-                        /**
-                         * @minItems 1
-                         */
-                        ownerC: [
-                            MittwaldAPIV2.Components.Schemas.DomainHandleField,
-                            ...MittwaldAPIV2.Components.Schemas.DomainHandleField[]
-                        ];
+                        [k: string]: unknown;
                     }
                     type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
                     type Query = {};
                 }
                 namespace Responses {
-                    namespace $200 {
+                    namespace $204 {
                         namespace Content {
-                            interface ApplicationJson {
-                                [k: string]: unknown;
-                            }
+                            type Empty = unknown;
                         }
                     }
                     namespace $400 {
@@ -14885,32 +14901,25 @@ export declare module MittwaldAPIV2 {
                 }
             }
         }
-        namespace V2DomainsDomainIdProjectId {
-            namespace Put {
+        namespace V2DomainRegistrable {
+            namespace Post {
                 namespace Parameters {
-                    type Path = {
-                        domainId: string;
-                    };
+                    type Path = {};
                     interface RequestBody {
-                        projectId?: string;
+                        domain: string;
                     }
-                    type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
+                    type Header = {};
                     type Query = {};
                 }
                 namespace Responses {
-                    namespace $204 {
-                        namespace Content {
-                            type Empty = unknown;
-                        }
-                    }
-                    namespace $400 {
+                    namespace $200 {
                         namespace Content {
                             interface ApplicationJson {
-                                [k: string]: unknown;
+                                registrable: boolean;
                             }
                         }
                     }
-                    namespace $404 {
+                    namespace $400 {
                         namespace Content {
                             interface ApplicationJson {
                                 [k: string]: unknown;
@@ -14927,35 +14936,25 @@ export declare module MittwaldAPIV2 {
                 }
             }
         }
-        namespace V2DomainsDomainIdNameservers {
-            namespace Put {
+        namespace V2Domains {
+            namespace Post {
                 namespace Parameters {
-                    type Path = {
-                        domainId: string;
-                    };
+                    type Path = {};
                     interface RequestBody {
-                        /**
-                         * @minItems 2
-                         */
-                        nameservers?: [string, string, ...string[]];
+                        domain: string;
                     }
-                    type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
+                    type Header = {};
                     type Query = {};
                 }
                 namespace Responses {
-                    namespace $204 {
-                        namespace Content {
-                            type Empty = unknown;
-                        }
-                    }
-                    namespace $400 {
+                    namespace $200 {
                         namespace Content {
                             interface ApplicationJson {
-                                [k: string]: unknown;
+                                available: boolean;
                             }
                         }
                     }
-                    namespace $404 {
+                    namespace $400 {
                         namespace Content {
                             interface ApplicationJson {
                                 [k: string]: unknown;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MittwaldAPIClientVersion = '3.0.23';
+export declare const MittwaldAPIClientVersion = '3.0.24';