@mittwald/api-client 4.474.0 → 4.476.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -498,6 +498,10 @@ export declare namespace MittwaldAPIV2 {
498
498
  type RequestData = InferredRequestData<typeof descriptors.contributorGetLoginLink>;
499
499
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.contributorGetLoginLink, TStatus>;
500
500
  }
501
+ namespace ContributorGetOauthClient {
502
+ type RequestData = InferredRequestData<typeof descriptors.contributorGetOauthClient>;
503
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.contributorGetOauthClient, TStatus>;
504
+ }
501
505
  namespace ContributorListContractPartnersOfContributor {
502
506
  type RequestData = InferredRequestData<typeof descriptors.contributorListContractPartnersOfContributor>;
503
507
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.contributorListContractPartnersOfContributor, TStatus>;
@@ -858,6 +862,22 @@ export declare namespace MittwaldAPIV2 {
858
862
  type RequestData = InferredRequestData<typeof descriptors.userUpdateAccount>;
859
863
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userUpdateAccount, TStatus>;
860
864
  }
865
+ namespace DnsListDnsZoneFileImports {
866
+ type RequestData = InferredRequestData<typeof descriptors.dnsListDnsZoneFileImports>;
867
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsListDnsZoneFileImports, TStatus>;
868
+ }
869
+ namespace DnsCreateDnsZoneFileImport {
870
+ type RequestData = InferredRequestData<typeof descriptors.dnsCreateDnsZoneFileImport>;
871
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsCreateDnsZoneFileImport, TStatus>;
872
+ }
873
+ namespace DnsListDnsZones {
874
+ type RequestData = InferredRequestData<typeof descriptors.dnsListDnsZones>;
875
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsListDnsZones, TStatus>;
876
+ }
877
+ namespace DnsCreateProjectDnsZone {
878
+ type RequestData = InferredRequestData<typeof descriptors.dnsCreateProjectDnsZone>;
879
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsCreateProjectDnsZone, TStatus>;
880
+ }
861
881
  namespace DnsGetDnsZone {
862
882
  type RequestData = InferredRequestData<typeof descriptors.dnsGetDnsZone>;
863
883
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsGetDnsZone, TStatus>;
@@ -866,18 +886,14 @@ export declare namespace MittwaldAPIV2 {
866
886
  type RequestData = InferredRequestData<typeof descriptors.dnsDeleteDnsZone>;
867
887
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsDeleteDnsZone, TStatus>;
868
888
  }
889
+ namespace DnsGetDnsZoneFileImport {
890
+ type RequestData = InferredRequestData<typeof descriptors.dnsGetDnsZoneFileImport>;
891
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsGetDnsZoneFileImport, TStatus>;
892
+ }
869
893
  namespace DnsGetZoneFile {
870
894
  type RequestData = InferredRequestData<typeof descriptors.dnsGetZoneFile>;
871
895
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsGetZoneFile, TStatus>;
872
896
  }
873
- namespace DnsListDnsZones {
874
- type RequestData = InferredRequestData<typeof descriptors.dnsListDnsZones>;
875
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsListDnsZones, TStatus>;
876
- }
877
- namespace DnsCreateProjectDnsZone {
878
- type RequestData = InferredRequestData<typeof descriptors.dnsCreateProjectDnsZone>;
879
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsCreateProjectDnsZone, TStatus>;
880
- }
881
897
  namespace DnsSetRecordSetManaged {
882
898
  type RequestData = InferredRequestData<typeof descriptors.dnsSetRecordSetManaged>;
883
899
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsSetRecordSetManaged, TStatus>;
@@ -1686,22 +1702,6 @@ export declare namespace MittwaldAPIV2 {
1686
1702
  type RequestData = InferredRequestData<typeof descriptors.sslListCertificates>;
1687
1703
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.sslListCertificates, TStatus>;
1688
1704
  }
1689
- namespace StoragespaceGetProjectStatistics {
1690
- type RequestData = InferredRequestData<typeof descriptors.storagespaceGetProjectStatistics>;
1691
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.storagespaceGetProjectStatistics, TStatus>;
1692
- }
1693
- namespace StoragespaceUpdateProjectStatistics {
1694
- type RequestData = InferredRequestData<typeof descriptors.storagespaceUpdateProjectStatistics>;
1695
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.storagespaceUpdateProjectStatistics, TStatus>;
1696
- }
1697
- namespace StoragespaceGetServerStatistics {
1698
- type RequestData = InferredRequestData<typeof descriptors.storagespaceGetServerStatistics>;
1699
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.storagespaceGetServerStatistics, TStatus>;
1700
- }
1701
- namespace StoragespaceUpdateServerStatistics {
1702
- type RequestData = InferredRequestData<typeof descriptors.storagespaceUpdateServerStatistics>;
1703
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.storagespaceUpdateServerStatistics, TStatus>;
1704
- }
1705
1705
  namespace UserAddPhoneNumber {
1706
1706
  type RequestData = InferredRequestData<typeof descriptors.userAddPhoneNumber>;
1707
1707
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userAddPhoneNumber, TStatus>;
@@ -1902,6 +1902,10 @@ export declare namespace MittwaldAPIV2 {
1902
1902
  type RequestData = InferredRequestData<typeof descriptors.userResendVerificationEmail>;
1903
1903
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userResendVerificationEmail, TStatus>;
1904
1904
  }
1905
+ namespace UserSearchedLeakedPasswordsByRange {
1906
+ type RequestData = InferredRequestData<typeof descriptors.userSearchedLeakedPasswordsByRange>;
1907
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userSearchedLeakedPasswordsByRange, TStatus>;
1908
+ }
1905
1909
  namespace UserSpotlightFeedback {
1906
1910
  type RequestData = InferredRequestData<typeof descriptors.userSpotlightFeedback>;
1907
1911
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userSpotlightFeedback, TStatus>;
@@ -1934,25 +1938,21 @@ export declare namespace MittwaldAPIV2 {
1934
1938
  type RequestData = InferredRequestData<typeof descriptors.verificationVerifyCompany>;
1935
1939
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.verificationVerifyCompany, TStatus>;
1936
1940
  }
1937
- namespace ContributorGetOauthClient {
1938
- type RequestData = InferredRequestData<typeof descriptors.contributorGetOauthClient>;
1939
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.contributorGetOauthClient, TStatus>;
1940
- }
1941
- namespace UserSearchedLeakedPasswordsByRange {
1942
- type RequestData = InferredRequestData<typeof descriptors.userSearchedLeakedPasswordsByRange>;
1943
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userSearchedLeakedPasswordsByRange, TStatus>;
1941
+ namespace StoragespaceGetServerStatistics {
1942
+ type RequestData = InferredRequestData<typeof descriptors.storagespaceGetServerStatistics>;
1943
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.storagespaceGetServerStatistics, TStatus>;
1944
1944
  }
1945
- namespace DnsListDnsZoneFileImports {
1946
- type RequestData = InferredRequestData<typeof descriptors.dnsListDnsZoneFileImports>;
1947
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsListDnsZoneFileImports, TStatus>;
1945
+ namespace StoragespaceUpdateServerStatistics {
1946
+ type RequestData = InferredRequestData<typeof descriptors.storagespaceUpdateServerStatistics>;
1947
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.storagespaceUpdateServerStatistics, TStatus>;
1948
1948
  }
1949
- namespace DnsCreateDnsZoneFileImport {
1950
- type RequestData = InferredRequestData<typeof descriptors.dnsCreateDnsZoneFileImport>;
1951
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsCreateDnsZoneFileImport, TStatus>;
1949
+ namespace StoragespaceGetProjectStatistics {
1950
+ type RequestData = InferredRequestData<typeof descriptors.storagespaceGetProjectStatistics>;
1951
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.storagespaceGetProjectStatistics, TStatus>;
1952
1952
  }
1953
- namespace DnsGetDnsZoneFileImport {
1954
- type RequestData = InferredRequestData<typeof descriptors.dnsGetDnsZoneFileImport>;
1955
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsGetDnsZoneFileImport, TStatus>;
1953
+ namespace StoragespaceUpdateProjectStatistics {
1954
+ type RequestData = InferredRequestData<typeof descriptors.storagespaceUpdateProjectStatistics>;
1955
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.storagespaceUpdateProjectStatistics, TStatus>;
1956
1956
  }
1957
1957
  }
1958
1958
  namespace Components {
@@ -2185,6 +2185,7 @@ export declare namespace MittwaldAPIV2 {
2185
2185
  */
2186
2186
  interface AppApp {
2187
2187
  actionCapabilities?: MittwaldAPIV2.Components.Schemas.AppActionCapabilities;
2188
+ description?: MittwaldAPIV2.Components.Schemas.AppTranslatedString;
2188
2189
  id: string;
2189
2190
  name: string;
2190
2191
  tags: string[];
@@ -4014,6 +4015,90 @@ export declare namespace MittwaldAPIV2 {
4014
4015
  name: string;
4015
4016
  number: string;
4016
4017
  }
4018
+ interface DnsCreateZoneFileImportResponse {
4019
+ /**
4020
+ * Everything that will not be imported (invalid records, unsupported record types, CNAME conflicts, placement problems, parse errors). Empty on a real import, since any conflict rejects the whole import with 412 (all-or-nothing).
4021
+ */
4022
+ conflicts: MittwaldAPIV2.Components.Schemas.DnsImportConflict[];
4023
+ /**
4024
+ * ID of the started import job. Absent on a dry-run (dryRun=true), which creates no job.
4025
+ */
4026
+ id?: string;
4027
+ /**
4028
+ * The importable target zones (one per distinct owner name), each with the record sets that would be set. On a dry-run this is the preview; on a real import it is the plan that was applied.
4029
+ */
4030
+ zones: MittwaldAPIV2.Components.Schemas.DnsZoneImportPreview[];
4031
+ }
4032
+ interface DnsImportConflict {
4033
+ /**
4034
+ * Machine-readable conflict kind: parseError (a zone-file line could not be parsed), invalidRecord (a record failed the same schema validation the write commands apply), invalidZoneName (the owner name is not a valid zone name, e.g. a wildcard *.example.com), unsupportedRecordType (an RR type dns-service does not import), cnameConflict (a CNAME shares a name with other record types), foreignCustomerIngress (the zone's enabled ingress belongs to another organization), rootZoneUnavailable (a subzone whose root zone is neither importable nor already existing).
4035
+ */
4036
+ code: "parseError" | "invalidRecord" | "invalidZoneName" | "unsupportedRecordType" | "cnameConflict" | "foreignCustomerIngress" | "rootZoneUnavailable";
4037
+ /**
4038
+ * Human-readable explanation of the conflict, suitable for surfacing to the user.
4039
+ */
4040
+ message: string;
4041
+ /**
4042
+ * Offending record/owner name. Empty for a file-level parse error, where sourceLine locates the bad line.
4043
+ */
4044
+ name?: string;
4045
+ /**
4046
+ * Only on an invalidRecord conflict: the offending record's rendered value (e.g. "10 ." for an MX).
4047
+ */
4048
+ record?: string;
4049
+ /**
4050
+ * Only on an invalidRecord conflict: the offending record's set type.
4051
+ */
4052
+ recordSetType?: "a" | "mx" | "txt" | "cname" | "srv" | "caa";
4053
+ /**
4054
+ * 1-based line number in the uploaded zone file, set for a file-level parse error (code parseError); 0 otherwise.
4055
+ */
4056
+ sourceLine?: number;
4057
+ }
4058
+ interface DnsImportRecord {
4059
+ /**
4060
+ * CAA flags. Only set for CAA records.
4061
+ */
4062
+ flags?: number;
4063
+ /**
4064
+ * SRV port. Only set for SRV records.
4065
+ */
4066
+ port?: number;
4067
+ /**
4068
+ * MX preference / SRV priority. Only set for MX and SRV records.
4069
+ */
4070
+ priority?: number;
4071
+ /**
4072
+ * CAA tag (e.g. issue, issuewild, iodef). Only set for CAA records.
4073
+ */
4074
+ tag?: string;
4075
+ /**
4076
+ * The record's value: an IP address for A/AAAA, the target FQDN for MX/CNAME/SRV, the text for TXT, the value for CAA.
4077
+ */
4078
+ value: string;
4079
+ /**
4080
+ * SRV weight. Only set for SRV records.
4081
+ */
4082
+ weight?: number;
4083
+ }
4084
+ interface DnsImportRecordSet {
4085
+ /**
4086
+ * The individual records in the set.
4087
+ */
4088
+ records: MittwaldAPIV2.Components.Schemas.DnsImportRecord[];
4089
+ /**
4090
+ * True when the source TTLs had to be normalized to ttlSeconds — because they diverged within the set or fell below the 60s minimum. Informational; the import still uses ttlSeconds.
4091
+ */
4092
+ ttlNormalized: boolean;
4093
+ /**
4094
+ * TTL applied to the whole set, in seconds. Collapsed to a single value across the set: the minimum of the source TTLs, floored to the 60s minimum.
4095
+ */
4096
+ ttlSeconds: number;
4097
+ /**
4098
+ * Record-set type.
4099
+ */
4100
+ type: "a" | "mx" | "txt" | "cname" | "srv" | "caa";
4101
+ }
4017
4102
  type DnsRecordCAA = MittwaldAPIV2.Components.Schemas.DnsRecordUnset | MittwaldAPIV2.Components.Schemas.DnsRecordCAAComponent;
4018
4103
  interface DnsRecordCAAComponent {
4019
4104
  /**
@@ -4124,6 +4209,38 @@ export declare namespace MittwaldAPIV2 {
4124
4209
  txt: MittwaldAPIV2.Components.Schemas.DnsRecordTXT;
4125
4210
  };
4126
4211
  }
4212
+ interface DnsZoneFileImport {
4213
+ /**
4214
+ * When the import job was created (publish time of the created event).
4215
+ */
4216
+ createdAt: string;
4217
+ id: string;
4218
+ importedZones: string[];
4219
+ projectId: string;
4220
+ skippedZones: {
4221
+ name: string;
4222
+ reason: string;
4223
+ }[];
4224
+ status: "running" | "succeeded" | "completedWithErrors";
4225
+ }
4226
+ interface DnsZoneImportPreview {
4227
+ /**
4228
+ * Whether a zone with this name already exists. On import its record sets are overwritten rather than the import failing.
4229
+ */
4230
+ alreadyExists: boolean;
4231
+ /**
4232
+ * Fully-qualified name of the target zone. Every distinct owner name becomes its own zone. Only importable zones are listed; a zone named by a conflict is omitted.
4233
+ */
4234
+ name: string;
4235
+ /**
4236
+ * The record sets that would be set on the zone — one per record type present for this owner name.
4237
+ */
4238
+ recordSets: MittwaldAPIV2.Components.Schemas.DnsImportRecordSet[];
4239
+ /**
4240
+ * Project the zone would be created in. Always set, since only importable zones are listed.
4241
+ */
4242
+ targetProjectId: string;
4243
+ }
4127
4244
  interface DomainAuthCode {
4128
4245
  expires?: string;
4129
4246
  value: string;
@@ -7105,62 +7222,6 @@ export declare namespace MittwaldAPIV2 {
7105
7222
  updatedAt?: string;
7106
7223
  }
7107
7224
  type SslProjectCertificateStatus = "issuing" | "ready" | "cnameError" | "error" | "unspecified";
7108
- type StoragespaceStatisticsCategoryKind = "webspace" | "projectBackup" | "mailAddress" | "mysqlDatabase" | "redisDatabase" | "containerVolume";
7109
- interface StoragespaceStatisticsCategory {
7110
- kind: MittwaldAPIV2.Components.Schemas.StoragespaceStatisticsCategoryKind;
7111
- resources?: MittwaldAPIV2.Components.Schemas.StoragespaceStatisticsResource[];
7112
- totalUsageInBytes: number;
7113
- }
7114
- type StoragespaceStatisticsKind = "server" | "project";
7115
- interface StoragespaceStatisticsMeta {
7116
- isExceeding?: boolean;
7117
- /**
7118
- * The last exceedance limit in bytes during the exceedance time, therefore can differ from the current limit. It is retained as a historical record of the most recent exceedance and does not reset once set.
7119
- */
7120
- lastExceedanceLimitInBytes?: number;
7121
- /**
7122
- * The last total exceedance in bytes related to the limit during the exceedance time, see lastExceedanceLimitInBytes. It is retained as a historical record of the most recent exceedance and does not reset once set.
7123
- */
7124
- lastTotalExceedanceInBytes?: number;
7125
- /**
7126
- * The last total exceedance date. It is retained as a historical record of the most recent exceedance and does not reset once set.
7127
- */
7128
- lastTotalExceedanceInBytesSetAt?: string;
7129
- limitInBytes?: number;
7130
- /**
7131
- * If true, set notification threshold is used as limit for meta calculations. E.g. for projects with a parent server.
7132
- */
7133
- notificationThresholdUsedAsLimit?: boolean;
7134
- /**
7135
- * The current total exceedance in bytes.
7136
- */
7137
- totalExceedanceInBytes?: number;
7138
- /**
7139
- * The current total exceedance date.
7140
- */
7141
- totalExceedanceInBytesSetAt?: string;
7142
- totalFreeInBytes?: number;
7143
- totalFreeInPercentage?: number;
7144
- totalUsageInBytes: number;
7145
- totalUsageInPercentage?: number;
7146
- }
7147
- interface StoragespaceStatisticsResource {
7148
- description?: string;
7149
- id: string;
7150
- name: string;
7151
- usageInBytes: number;
7152
- usageInBytesSetAt: string;
7153
- }
7154
- interface StoragespaceStatistics {
7155
- childStatistics?: MittwaldAPIV2.Components.Schemas.StoragespaceStatistics[];
7156
- description?: string;
7157
- id: string;
7158
- kind: MittwaldAPIV2.Components.Schemas.StoragespaceStatisticsKind;
7159
- meta: MittwaldAPIV2.Components.Schemas.StoragespaceStatisticsMeta;
7160
- name: string;
7161
- notificationThresholdInBytes?: number;
7162
- statisticCategories?: MittwaldAPIV2.Components.Schemas.StoragespaceStatisticsCategory[];
7163
- }
7164
7225
  interface SignupAccount {
7165
7226
  email?: string;
7166
7227
  /**
@@ -7371,121 +7432,68 @@ export declare namespace MittwaldAPIV2 {
7371
7432
  }
7372
7433
  type VerificationEmailOrigin = "IS_MITTWALD" | "IS_NOT_MITTWALD" | "COULD_BE_MITTWALD";
7373
7434
  type ContainerVolumeSortOrder = "nameAsc" | "nameDesc" | "storageAsc" | "storageDesc";
7374
- interface DnsCreateZoneFileImportResponse {
7375
- /**
7376
- * Everything that will not be imported (invalid records, unsupported record types, CNAME conflicts, placement problems, parse errors). Empty on a real import, since any conflict rejects the whole import with 412 (all-or-nothing).
7377
- */
7378
- conflicts: MittwaldAPIV2.Components.Schemas.DnsImportConflict[];
7379
- /**
7380
- * ID of the started import job. Absent on a dry-run (dryRun=true), which creates no job.
7381
- */
7382
- id?: string;
7383
- /**
7384
- * The importable target zones (one per distinct owner name), each with the record sets that would be set. On a dry-run this is the preview; on a real import it is the plan that was applied.
7385
- */
7386
- zones: MittwaldAPIV2.Components.Schemas.DnsZoneImportPreview[];
7387
- }
7388
- interface DnsZoneImportPreview {
7389
- /**
7390
- * Whether a zone with this name already exists. On import its record sets are overwritten rather than the import failing.
7391
- */
7392
- alreadyExists: boolean;
7393
- /**
7394
- * Fully-qualified name of the target zone. Every distinct owner name becomes its own zone. Only importable zones are listed; a zone named by a conflict is omitted.
7395
- */
7435
+ type StoragespaceStatisticsKind = "server" | "project";
7436
+ interface StoragespaceStatistics {
7437
+ childStatistics?: MittwaldAPIV2.Components.Schemas.StoragespaceStatistics[];
7438
+ description?: string;
7439
+ id: string;
7440
+ kind: MittwaldAPIV2.Components.Schemas.StoragespaceStatisticsKind;
7441
+ meta: MittwaldAPIV2.Components.Schemas.StoragespaceStatisticsMeta;
7396
7442
  name: string;
7397
- /**
7398
- * The record sets that would be set on the zone — one per record type present for this owner name.
7399
- */
7400
- recordSets: MittwaldAPIV2.Components.Schemas.DnsImportRecordSet[];
7401
- /**
7402
- * Project the zone would be created in. Always set, since only importable zones are listed.
7403
- */
7404
- targetProjectId: string;
7443
+ notificationThresholdInBytes?: number;
7444
+ statisticCategories?: MittwaldAPIV2.Components.Schemas.StoragespaceStatisticsCategory[];
7405
7445
  }
7406
- interface DnsImportRecordSet {
7407
- /**
7408
- * The individual records in the set.
7409
- */
7410
- records: MittwaldAPIV2.Components.Schemas.DnsImportRecord[];
7411
- /**
7412
- * True when the source TTLs had to be normalized to ttlSeconds — because they diverged within the set or fell below the 60s minimum. Informational; the import still uses ttlSeconds.
7413
- */
7414
- ttlNormalized: boolean;
7415
- /**
7416
- * TTL applied to the whole set, in seconds. Collapsed to a single value across the set: the minimum of the source TTLs, floored to the 60s minimum.
7417
- */
7418
- ttlSeconds: number;
7419
- /**
7420
- * Record-set type.
7421
- */
7422
- type: "a" | "mx" | "txt" | "cname" | "srv" | "caa";
7446
+ type StoragespaceStatisticsCategoryKind = "webspace" | "projectBackup" | "mailAddress" | "mysqlDatabase" | "redisDatabase" | "containerVolume";
7447
+ interface StoragespaceStatisticsResource {
7448
+ description?: string;
7449
+ id: string;
7450
+ name: string;
7451
+ usageInBytes: number;
7452
+ usageInBytesSetAt: string;
7423
7453
  }
7424
- interface DnsImportRecord {
7425
- /**
7426
- * CAA flags. Only set for CAA records.
7427
- */
7428
- flags?: number;
7429
- /**
7430
- * SRV port. Only set for SRV records.
7431
- */
7432
- port?: number;
7433
- /**
7434
- * MX preference / SRV priority. Only set for MX and SRV records.
7435
- */
7436
- priority?: number;
7437
- /**
7438
- * CAA tag (e.g. issue, issuewild, iodef). Only set for CAA records.
7439
- */
7440
- tag?: string;
7441
- /**
7442
- * The record's value: an IP address for A/AAAA, the target FQDN for MX/CNAME/SRV, the text for TXT, the value for CAA.
7443
- */
7444
- value: string;
7445
- /**
7446
- * SRV weight. Only set for SRV records.
7447
- */
7448
- weight?: number;
7454
+ interface StoragespaceStatisticsCategory {
7455
+ kind: MittwaldAPIV2.Components.Schemas.StoragespaceStatisticsCategoryKind;
7456
+ resources?: MittwaldAPIV2.Components.Schemas.StoragespaceStatisticsResource[];
7457
+ totalUsageInBytes: number;
7449
7458
  }
7450
- interface DnsImportConflict {
7459
+ interface StoragespaceStatisticsMeta {
7460
+ isExceeding?: boolean;
7451
7461
  /**
7452
- * Machine-readable conflict kind: parseError (a zone-file line could not be parsed), invalidRecord (a record failed the same schema validation the write commands apply), invalidZoneName (the owner name is not a valid zone name, e.g. a wildcard *.example.com), unsupportedRecordType (an RR type dns-service does not import), cnameConflict (a CNAME shares a name with other record types), foreignCustomerIngress (the zone's enabled ingress belongs to another organization), rootZoneUnavailable (a subzone whose root zone is neither importable nor already existing).
7462
+ * The last exceedance limit in bytes during the exceedance time, therefore can differ from the current limit. It is retained as a historical record of the most recent exceedance and does not reset once set.
7453
7463
  */
7454
- code: "parseError" | "invalidRecord" | "invalidZoneName" | "unsupportedRecordType" | "cnameConflict" | "foreignCustomerIngress" | "rootZoneUnavailable";
7464
+ lastExceedanceLimitInBytes?: number;
7455
7465
  /**
7456
- * Human-readable explanation of the conflict, suitable for surfacing to the user.
7466
+ * The last total exceedance in bytes related to the limit during the exceedance time, see lastExceedanceLimitInBytes. It is retained as a historical record of the most recent exceedance and does not reset once set.
7457
7467
  */
7458
- message: string;
7468
+ lastTotalExceedanceInBytes?: number;
7459
7469
  /**
7460
- * Offending record/owner name. Empty for a file-level parse error, where sourceLine locates the bad line.
7470
+ * The last total exceedance date. It is retained as a historical record of the most recent exceedance and does not reset once set.
7461
7471
  */
7462
- name?: string;
7472
+ lastTotalExceedanceInBytesSetAt?: string;
7473
+ limitInBytes?: number;
7463
7474
  /**
7464
- * Only on an invalidRecord conflict: the offending record's rendered value (e.g. "10 ." for an MX).
7475
+ * If true, set notification threshold is used as limit for meta calculations. E.g. for projects with a parent server.
7465
7476
  */
7466
- record?: string;
7477
+ notificationThresholdUsedAsLimit?: boolean;
7467
7478
  /**
7468
- * Only on an invalidRecord conflict: the offending record's set type.
7479
+ * The current total exceedance in bytes.
7469
7480
  */
7470
- recordSetType?: "a" | "mx" | "txt" | "cname" | "srv" | "caa";
7481
+ totalExceedanceInBytes?: number;
7471
7482
  /**
7472
- * 1-based line number in the uploaded zone file, set for a file-level parse error (code parseError); 0 otherwise.
7483
+ * The current total exceedance date.
7473
7484
  */
7474
- sourceLine?: number;
7485
+ totalExceedanceInBytesSetAt?: string;
7486
+ totalFreeInBytes?: number;
7487
+ totalFreeInPercentage?: number;
7488
+ totalUsageInBytes: number;
7489
+ totalUsageInPercentage?: number;
7475
7490
  }
7476
- interface DnsZoneFileImport {
7477
- /**
7478
- * When the import job was created (publish time of the created event).
7479
- */
7480
- createdAt: string;
7481
- id: string;
7482
- importedZones: string[];
7483
- projectId: string;
7484
- skippedZones: {
7485
- name: string;
7486
- reason: string;
7487
- }[];
7488
- status: "running" | "succeeded" | "completedWithErrors";
7491
+ /**
7492
+ * A text with a german and an english translation.
7493
+ */
7494
+ interface AppTranslatedString {
7495
+ de: string;
7496
+ en: string;
7489
7497
  }
7490
7498
  interface CommonsAddress {
7491
7499
  street: string;
@@ -14489,6 +14497,46 @@ export declare namespace MittwaldAPIV2 {
14489
14497
  }
14490
14498
  }
14491
14499
  }
14500
+ namespace V2Oauth2ClientsOauthClientId {
14501
+ namespace Get {
14502
+ namespace Parameters {
14503
+ type Path = {
14504
+ oauthClientId: string;
14505
+ };
14506
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
14507
+ type Query = {};
14508
+ }
14509
+ namespace Responses {
14510
+ namespace $200 {
14511
+ namespace Content {
14512
+ interface ApplicationJson {
14513
+ allowedGrantTypes?: string[];
14514
+ allowedRedirectUris?: string[];
14515
+ allowedScopes?: string[];
14516
+ description?: string;
14517
+ humanReadableName: string;
14518
+ id: string;
14519
+ type?: "public" | "confidential";
14520
+ }
14521
+ }
14522
+ }
14523
+ namespace $429 {
14524
+ namespace Content {
14525
+ interface ApplicationJson {
14526
+ [k: string]: unknown;
14527
+ }
14528
+ }
14529
+ }
14530
+ namespace Default {
14531
+ namespace Content {
14532
+ interface ApplicationJson {
14533
+ [k: string]: unknown;
14534
+ }
14535
+ }
14536
+ }
14537
+ }
14538
+ }
14539
+ }
14492
14540
  namespace V2ContributorsContributorIdContractPartners {
14493
14541
  namespace Get {
14494
14542
  namespace Parameters {
@@ -19079,8 +19127,6 @@ export declare namespace MittwaldAPIV2 {
19079
19127
  namespace V2ProjectsProjectIdLeave { }
19080
19128
  namespace V2ProjectsProjectIdDescription { }
19081
19129
  namespace V2ServersServerIdDescription { }
19082
- namespace V2ProjectsProjectIdStorageSpaceNotificationThreshold { }
19083
- namespace V2ServersServerIdStorageSpaceNotificationThreshold { }
19084
19130
  namespace V2SignupEmail { }
19085
19131
  namespace V2SignupTokenCheck { }
19086
19132
  namespace V2UsersSelfCredentialsToken { }
@@ -19142,22 +19188,25 @@ export declare namespace MittwaldAPIV2 {
19142
19188
  namespace V2SignupSessions { }
19143
19189
  namespace V2SignupSessionsTokenId { }
19144
19190
  namespace V2SignupEmailVerify { }
19145
- namespace V2DnsZones { }
19146
- namespace V2DnsZones { }
19147
- namespace V2DnsZonesDnsZoneId { }
19148
- namespace V2DnsZonesDnsZoneId {
19191
+ namespace V2ProjectsProjectIdDnsZoneImports {
19149
19192
  namespace Get {
19150
19193
  namespace Parameters {
19151
19194
  type Path = {
19152
- dnsZoneId: string;
19195
+ projectId: string;
19153
19196
  };
19154
19197
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
19155
- type Query = {};
19198
+ type Query = {
19199
+ limit?: number;
19200
+ skip?: number;
19201
+ page?: number;
19202
+ sort?: "createdAt";
19203
+ order?: "asc" | "desc";
19204
+ };
19156
19205
  }
19157
19206
  namespace Responses {
19158
19207
  namespace $200 {
19159
19208
  namespace Content {
19160
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.DnsZone;
19209
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.DnsZoneFileImport[];
19161
19210
  }
19162
19211
  }
19163
19212
  namespace $400 {
@@ -19183,18 +19232,26 @@ export declare namespace MittwaldAPIV2 {
19183
19232
  }
19184
19233
  }
19185
19234
  }
19186
- namespace Delete {
19235
+ namespace Post {
19187
19236
  namespace Parameters {
19188
19237
  type Path = {
19189
- dnsZoneId: string;
19238
+ projectId: string;
19190
19239
  };
19240
+ interface RequestBody {
19241
+ /**
19242
+ * Raw RFC-1035 zone file content to import.
19243
+ */
19244
+ zoneFile: string;
19245
+ }
19191
19246
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
19192
- type Query = {};
19247
+ type Query = {
19248
+ dryRun?: boolean;
19249
+ };
19193
19250
  }
19194
19251
  namespace Responses {
19195
- namespace $204 {
19252
+ namespace $200 {
19196
19253
  namespace Content {
19197
- type Empty = unknown;
19254
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.DnsCreateZoneFileImportResponse;
19198
19255
  }
19199
19256
  }
19200
19257
  namespace $400 {
@@ -19204,39 +19261,14 @@ export declare namespace MittwaldAPIV2 {
19204
19261
  }
19205
19262
  }
19206
19263
  }
19207
- namespace $429 {
19208
- namespace Content {
19209
- interface ApplicationJson {
19210
- [k: string]: unknown;
19211
- }
19212
- }
19213
- }
19214
- namespace Default {
19264
+ namespace $404 {
19215
19265
  namespace Content {
19216
19266
  interface ApplicationJson {
19217
19267
  [k: string]: unknown;
19218
19268
  }
19219
19269
  }
19220
19270
  }
19221
- }
19222
- }
19223
- }
19224
- namespace V2DnsZonesDnsZoneIdZoneFile {
19225
- namespace Get {
19226
- namespace Parameters {
19227
- type Path = {
19228
- dnsZoneId: string;
19229
- };
19230
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
19231
- type Query = {};
19232
- }
19233
- namespace Responses {
19234
- namespace $200 {
19235
- namespace Content {
19236
- type TextPlain = string;
19237
- }
19238
- }
19239
- namespace $400 {
19271
+ namespace $412 {
19240
19272
  namespace Content {
19241
19273
  interface ApplicationJson {
19242
19274
  [k: string]: unknown;
@@ -19260,7 +19292,8 @@ export declare namespace MittwaldAPIV2 {
19260
19292
  }
19261
19293
  }
19262
19294
  }
19263
- namespace V2ProjectsProjectIdDnsZones { }
19295
+ namespace V2DnsZones { }
19296
+ namespace V2DnsZones { }
19264
19297
  namespace V2ProjectsProjectIdDnsZones {
19265
19298
  namespace Get {
19266
19299
  namespace Parameters {
@@ -19366,23 +19399,186 @@ export declare namespace MittwaldAPIV2 {
19366
19399
  }
19367
19400
  }
19368
19401
  }
19369
- namespace V2DnsZonesDnsZoneIdRecordSetsRecordSetActionsSetManaged {
19370
- namespace Post {
19402
+ namespace V2DnsZonesDnsZoneId { }
19403
+ namespace V2DnsZonesDnsZoneId {
19404
+ namespace Get {
19371
19405
  namespace Parameters {
19372
19406
  type Path = {
19373
19407
  dnsZoneId: string;
19374
- recordSet: "a" | "mx";
19375
19408
  };
19376
- interface RequestBody {
19377
- }
19378
19409
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
19379
19410
  type Query = {};
19380
19411
  }
19381
19412
  namespace Responses {
19382
19413
  namespace $200 {
19383
19414
  namespace Content {
19384
- interface ApplicationJson {
19385
- ingressId?: string;
19415
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.DnsZone;
19416
+ }
19417
+ }
19418
+ namespace $400 {
19419
+ namespace Content {
19420
+ interface ApplicationJson {
19421
+ [k: string]: unknown;
19422
+ }
19423
+ }
19424
+ }
19425
+ namespace $429 {
19426
+ namespace Content {
19427
+ interface ApplicationJson {
19428
+ [k: string]: unknown;
19429
+ }
19430
+ }
19431
+ }
19432
+ namespace Default {
19433
+ namespace Content {
19434
+ interface ApplicationJson {
19435
+ [k: string]: unknown;
19436
+ }
19437
+ }
19438
+ }
19439
+ }
19440
+ }
19441
+ namespace Delete {
19442
+ namespace Parameters {
19443
+ type Path = {
19444
+ dnsZoneId: string;
19445
+ };
19446
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
19447
+ type Query = {};
19448
+ }
19449
+ namespace Responses {
19450
+ namespace $204 {
19451
+ namespace Content {
19452
+ type Empty = unknown;
19453
+ }
19454
+ }
19455
+ namespace $400 {
19456
+ namespace Content {
19457
+ interface ApplicationJson {
19458
+ [k: string]: unknown;
19459
+ }
19460
+ }
19461
+ }
19462
+ namespace $429 {
19463
+ namespace Content {
19464
+ interface ApplicationJson {
19465
+ [k: string]: unknown;
19466
+ }
19467
+ }
19468
+ }
19469
+ namespace Default {
19470
+ namespace Content {
19471
+ interface ApplicationJson {
19472
+ [k: string]: unknown;
19473
+ }
19474
+ }
19475
+ }
19476
+ }
19477
+ }
19478
+ }
19479
+ namespace V2DnsZoneImportsZoneFileImportId {
19480
+ namespace Get {
19481
+ namespace Parameters {
19482
+ type Path = {
19483
+ zoneFileImportId: string;
19484
+ };
19485
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
19486
+ type Query = {};
19487
+ }
19488
+ namespace Responses {
19489
+ namespace $200 {
19490
+ namespace Content {
19491
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.DnsZoneFileImport;
19492
+ }
19493
+ }
19494
+ namespace $400 {
19495
+ namespace Content {
19496
+ interface ApplicationJson {
19497
+ [k: string]: unknown;
19498
+ }
19499
+ }
19500
+ }
19501
+ namespace $404 {
19502
+ namespace Content {
19503
+ interface ApplicationJson {
19504
+ [k: string]: unknown;
19505
+ }
19506
+ }
19507
+ }
19508
+ namespace $429 {
19509
+ namespace Content {
19510
+ interface ApplicationJson {
19511
+ [k: string]: unknown;
19512
+ }
19513
+ }
19514
+ }
19515
+ namespace Default {
19516
+ namespace Content {
19517
+ interface ApplicationJson {
19518
+ [k: string]: unknown;
19519
+ }
19520
+ }
19521
+ }
19522
+ }
19523
+ }
19524
+ }
19525
+ namespace V2DnsZonesDnsZoneIdZoneFile {
19526
+ namespace Get {
19527
+ namespace Parameters {
19528
+ type Path = {
19529
+ dnsZoneId: string;
19530
+ };
19531
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
19532
+ type Query = {};
19533
+ }
19534
+ namespace Responses {
19535
+ namespace $200 {
19536
+ namespace Content {
19537
+ type TextPlain = string;
19538
+ }
19539
+ }
19540
+ namespace $400 {
19541
+ namespace Content {
19542
+ interface ApplicationJson {
19543
+ [k: string]: unknown;
19544
+ }
19545
+ }
19546
+ }
19547
+ namespace $429 {
19548
+ namespace Content {
19549
+ interface ApplicationJson {
19550
+ [k: string]: unknown;
19551
+ }
19552
+ }
19553
+ }
19554
+ namespace Default {
19555
+ namespace Content {
19556
+ interface ApplicationJson {
19557
+ [k: string]: unknown;
19558
+ }
19559
+ }
19560
+ }
19561
+ }
19562
+ }
19563
+ }
19564
+ namespace V2ProjectsProjectIdDnsZones { }
19565
+ namespace V2DnsZonesDnsZoneIdRecordSetsRecordSetActionsSetManaged {
19566
+ namespace Post {
19567
+ namespace Parameters {
19568
+ type Path = {
19569
+ dnsZoneId: string;
19570
+ recordSet: "a" | "mx";
19571
+ };
19572
+ interface RequestBody {
19573
+ }
19574
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
19575
+ type Query = {};
19576
+ }
19577
+ namespace Responses {
19578
+ namespace $200 {
19579
+ namespace Content {
19580
+ interface ApplicationJson {
19581
+ ingressId?: string;
19386
19582
  }
19387
19583
  }
19388
19584
  }
@@ -29854,19 +30050,22 @@ export declare namespace MittwaldAPIV2 {
29854
30050
  }
29855
30051
  }
29856
30052
  }
29857
- namespace V2ProjectsProjectIdStorageSpaceStatistics {
29858
- namespace Get {
30053
+ namespace V2UsersUserIdPhone {
30054
+ namespace Post {
29859
30055
  namespace Parameters {
29860
30056
  type Path = {
29861
- projectId: string;
30057
+ userId: string;
29862
30058
  };
30059
+ interface RequestBody {
30060
+ phoneNumber: string;
30061
+ }
29863
30062
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
29864
30063
  type Query = {};
29865
30064
  }
29866
30065
  namespace Responses {
29867
- namespace $200 {
30066
+ namespace $204 {
29868
30067
  namespace Content {
29869
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.StoragespaceStatistics;
30068
+ type Empty = unknown;
29870
30069
  }
29871
30070
  }
29872
30071
  namespace $400 {
@@ -29876,14 +30075,7 @@ export declare namespace MittwaldAPIV2 {
29876
30075
  }
29877
30076
  }
29878
30077
  }
29879
- namespace $403 {
29880
- namespace Content {
29881
- interface ApplicationJson {
29882
- [k: string]: unknown;
29883
- }
29884
- }
29885
- }
29886
- namespace $404 {
30078
+ namespace $409 {
29887
30079
  namespace Content {
29888
30080
  interface ApplicationJson {
29889
30081
  [k: string]: unknown;
@@ -29897,13 +30089,6 @@ export declare namespace MittwaldAPIV2 {
29897
30089
  }
29898
30090
  }
29899
30091
  }
29900
- namespace $500 {
29901
- namespace Content {
29902
- interface ApplicationJson {
29903
- [k: string]: unknown;
29904
- }
29905
- }
29906
- }
29907
30092
  namespace Default {
29908
30093
  namespace Content {
29909
30094
  interface ApplicationJson {
@@ -29913,14 +30098,11 @@ export declare namespace MittwaldAPIV2 {
29913
30098
  }
29914
30099
  }
29915
30100
  }
29916
- namespace Patch {
30101
+ namespace Delete {
29917
30102
  namespace Parameters {
29918
30103
  type Path = {
29919
- projectId: string;
30104
+ userId: string;
29920
30105
  };
29921
- interface RequestBody {
29922
- notificationThresholdInBytes?: number;
29923
- }
29924
30106
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
29925
30107
  type Query = {};
29926
30108
  }
@@ -29930,21 +30112,21 @@ export declare namespace MittwaldAPIV2 {
29930
30112
  type Empty = unknown;
29931
30113
  }
29932
30114
  }
29933
- namespace $403 {
30115
+ namespace $400 {
29934
30116
  namespace Content {
29935
30117
  interface ApplicationJson {
29936
30118
  [k: string]: unknown;
29937
30119
  }
29938
30120
  }
29939
30121
  }
29940
- namespace $429 {
30122
+ namespace $412 {
29941
30123
  namespace Content {
29942
30124
  interface ApplicationJson {
29943
30125
  [k: string]: unknown;
29944
30126
  }
29945
30127
  }
29946
30128
  }
29947
- namespace $500 {
30129
+ namespace $429 {
29948
30130
  namespace Content {
29949
30131
  interface ApplicationJson {
29950
30132
  [k: string]: unknown;
@@ -29961,250 +30143,50 @@ export declare namespace MittwaldAPIV2 {
29961
30143
  }
29962
30144
  }
29963
30145
  }
29964
- namespace V2ServersServerIdStorageSpaceStatistics {
29965
- namespace Get {
30146
+ namespace V2SignupAuthenticationMfa { }
30147
+ namespace V2AuthenticateMfa {
30148
+ namespace Post {
29966
30149
  namespace Parameters {
29967
- type Path = {
29968
- serverId: string;
30150
+ type Path = {};
30151
+ interface RequestBody {
30152
+ /**
30153
+ * The email of the user.
30154
+ */
30155
+ email: string;
30156
+ /**
30157
+ * The second factor - otp code or recovery code.
30158
+ */
30159
+ multiFactorCode: string;
30160
+ /**
30161
+ * The password of the user.
30162
+ */
30163
+ password: string;
30164
+ }
30165
+ type Header = {};
30166
+ type Query = {
30167
+ cookieOnly?: boolean;
29969
30168
  };
29970
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
29971
- type Query = {};
29972
30169
  }
29973
30170
  namespace Responses {
29974
30171
  namespace $200 {
29975
- namespace Content {
29976
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.StoragespaceStatistics;
29977
- }
29978
- }
29979
- namespace $400 {
29980
30172
  namespace Content {
29981
30173
  interface ApplicationJson {
29982
- [k: string]: unknown;
30174
+ /**
30175
+ * The expiration date of the token.
30176
+ */
30177
+ expires: string;
30178
+ /**
30179
+ * Refresh token to refresh your access token even after it has expired.
30180
+ */
30181
+ refreshToken: string;
30182
+ /**
30183
+ * Public token to identify yourself against the api gateway.
30184
+ */
30185
+ token: string;
29983
30186
  }
29984
30187
  }
29985
30188
  }
29986
- namespace $403 {
29987
- namespace Content {
29988
- interface ApplicationJson {
29989
- [k: string]: unknown;
29990
- }
29991
- }
29992
- }
29993
- namespace $404 {
29994
- namespace Content {
29995
- interface ApplicationJson {
29996
- [k: string]: unknown;
29997
- }
29998
- }
29999
- }
30000
- namespace $429 {
30001
- namespace Content {
30002
- interface ApplicationJson {
30003
- [k: string]: unknown;
30004
- }
30005
- }
30006
- }
30007
- namespace $500 {
30008
- namespace Content {
30009
- interface ApplicationJson {
30010
- [k: string]: unknown;
30011
- }
30012
- }
30013
- }
30014
- namespace Default {
30015
- namespace Content {
30016
- interface ApplicationJson {
30017
- [k: string]: unknown;
30018
- }
30019
- }
30020
- }
30021
- }
30022
- }
30023
- namespace Patch {
30024
- namespace Parameters {
30025
- type Path = {
30026
- serverId: string;
30027
- };
30028
- interface RequestBody {
30029
- notificationThresholdInBytes?: number;
30030
- }
30031
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30032
- type Query = {};
30033
- }
30034
- namespace Responses {
30035
- namespace $204 {
30036
- namespace Content {
30037
- type Empty = unknown;
30038
- }
30039
- }
30040
- namespace $403 {
30041
- namespace Content {
30042
- interface ApplicationJson {
30043
- [k: string]: unknown;
30044
- }
30045
- }
30046
- }
30047
- namespace $429 {
30048
- namespace Content {
30049
- interface ApplicationJson {
30050
- [k: string]: unknown;
30051
- }
30052
- }
30053
- }
30054
- namespace $500 {
30055
- namespace Content {
30056
- interface ApplicationJson {
30057
- [k: string]: unknown;
30058
- }
30059
- }
30060
- }
30061
- namespace Default {
30062
- namespace Content {
30063
- interface ApplicationJson {
30064
- [k: string]: unknown;
30065
- }
30066
- }
30067
- }
30068
- }
30069
- }
30070
- }
30071
- namespace V2UsersUserIdPhone {
30072
- namespace Post {
30073
- namespace Parameters {
30074
- type Path = {
30075
- userId: string;
30076
- };
30077
- interface RequestBody {
30078
- phoneNumber: string;
30079
- }
30080
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30081
- type Query = {};
30082
- }
30083
- namespace Responses {
30084
- namespace $204 {
30085
- namespace Content {
30086
- type Empty = unknown;
30087
- }
30088
- }
30089
- namespace $400 {
30090
- namespace Content {
30091
- interface ApplicationJson {
30092
- [k: string]: unknown;
30093
- }
30094
- }
30095
- }
30096
- namespace $409 {
30097
- namespace Content {
30098
- interface ApplicationJson {
30099
- [k: string]: unknown;
30100
- }
30101
- }
30102
- }
30103
- namespace $429 {
30104
- namespace Content {
30105
- interface ApplicationJson {
30106
- [k: string]: unknown;
30107
- }
30108
- }
30109
- }
30110
- namespace Default {
30111
- namespace Content {
30112
- interface ApplicationJson {
30113
- [k: string]: unknown;
30114
- }
30115
- }
30116
- }
30117
- }
30118
- }
30119
- namespace Delete {
30120
- namespace Parameters {
30121
- type Path = {
30122
- userId: string;
30123
- };
30124
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30125
- type Query = {};
30126
- }
30127
- namespace Responses {
30128
- namespace $204 {
30129
- namespace Content {
30130
- type Empty = unknown;
30131
- }
30132
- }
30133
- namespace $400 {
30134
- namespace Content {
30135
- interface ApplicationJson {
30136
- [k: string]: unknown;
30137
- }
30138
- }
30139
- }
30140
- namespace $412 {
30141
- namespace Content {
30142
- interface ApplicationJson {
30143
- [k: string]: unknown;
30144
- }
30145
- }
30146
- }
30147
- namespace $429 {
30148
- namespace Content {
30149
- interface ApplicationJson {
30150
- [k: string]: unknown;
30151
- }
30152
- }
30153
- }
30154
- namespace Default {
30155
- namespace Content {
30156
- interface ApplicationJson {
30157
- [k: string]: unknown;
30158
- }
30159
- }
30160
- }
30161
- }
30162
- }
30163
- }
30164
- namespace V2SignupAuthenticationMfa { }
30165
- namespace V2AuthenticateMfa {
30166
- namespace Post {
30167
- namespace Parameters {
30168
- type Path = {};
30169
- interface RequestBody {
30170
- /**
30171
- * The email of the user.
30172
- */
30173
- email: string;
30174
- /**
30175
- * The second factor - otp code or recovery code.
30176
- */
30177
- multiFactorCode: string;
30178
- /**
30179
- * The password of the user.
30180
- */
30181
- password: string;
30182
- }
30183
- type Header = {};
30184
- type Query = {
30185
- cookieOnly?: boolean;
30186
- };
30187
- }
30188
- namespace Responses {
30189
- namespace $200 {
30190
- namespace Content {
30191
- interface ApplicationJson {
30192
- /**
30193
- * The expiration date of the token.
30194
- */
30195
- expires: string;
30196
- /**
30197
- * Refresh token to refresh your access token even after it has expired.
30198
- */
30199
- refreshToken: string;
30200
- /**
30201
- * Public token to identify yourself against the api gateway.
30202
- */
30203
- token: string;
30204
- }
30205
- }
30206
- }
30207
- namespace $204 {
30189
+ namespace $204 {
30208
30190
  namespace Content {
30209
30191
  type Empty = unknown;
30210
30192
  }
@@ -32382,6 +32364,45 @@ export declare namespace MittwaldAPIV2 {
32382
32364
  }
32383
32365
  }
32384
32366
  namespace V2SignupMfaResetRecoverycodes { }
32367
+ namespace V2LeakedPasswordsPasswordHashPrefix {
32368
+ namespace Get {
32369
+ namespace Parameters {
32370
+ type Path = {
32371
+ passwordHashPrefix: string;
32372
+ };
32373
+ type Header = {};
32374
+ type Query = {};
32375
+ }
32376
+ namespace Responses {
32377
+ namespace $200 {
32378
+ namespace Content {
32379
+ type ApplicationJson = string[];
32380
+ }
32381
+ }
32382
+ namespace $400 {
32383
+ namespace Content {
32384
+ interface ApplicationJson {
32385
+ [k: string]: unknown;
32386
+ }
32387
+ }
32388
+ }
32389
+ namespace $429 {
32390
+ namespace Content {
32391
+ interface ApplicationJson {
32392
+ [k: string]: unknown;
32393
+ }
32394
+ }
32395
+ }
32396
+ namespace Default {
32397
+ namespace Content {
32398
+ interface ApplicationJson {
32399
+ [k: string]: unknown;
32400
+ }
32401
+ }
32402
+ }
32403
+ }
32404
+ }
32405
+ }
32385
32406
  namespace V2UsersSelfSpotlightsSpotlightIdFeedback {
32386
32407
  namespace Post {
32387
32408
  namespace Parameters {
@@ -32761,11 +32782,12 @@ export declare namespace MittwaldAPIV2 {
32761
32782
  }
32762
32783
  }
32763
32784
  }
32764
- namespace V2Oauth2ClientsOauthClientId {
32785
+ namespace V2ProjectsProjectIdStorageSpaceNotificationThreshold { }
32786
+ namespace V2ServersServerIdStorageSpaceStatistics {
32765
32787
  namespace Get {
32766
32788
  namespace Parameters {
32767
32789
  type Path = {
32768
- oauthClientId: string;
32790
+ serverId: string;
32769
32791
  };
32770
32792
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
32771
32793
  type Query = {};
@@ -32773,57 +32795,38 @@ export declare namespace MittwaldAPIV2 {
32773
32795
  namespace Responses {
32774
32796
  namespace $200 {
32775
32797
  namespace Content {
32776
- interface ApplicationJson {
32777
- allowedGrantTypes?: string[];
32778
- allowedRedirectUris?: string[];
32779
- allowedScopes?: string[];
32780
- description?: string;
32781
- humanReadableName: string;
32782
- id: string;
32783
- type?: "public" | "confidential";
32784
- }
32798
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.StoragespaceStatistics;
32785
32799
  }
32786
32800
  }
32787
- namespace $429 {
32801
+ namespace $400 {
32788
32802
  namespace Content {
32789
32803
  interface ApplicationJson {
32790
32804
  [k: string]: unknown;
32791
32805
  }
32792
32806
  }
32793
32807
  }
32794
- namespace Default {
32808
+ namespace $403 {
32795
32809
  namespace Content {
32796
32810
  interface ApplicationJson {
32797
32811
  [k: string]: unknown;
32798
32812
  }
32799
32813
  }
32800
32814
  }
32801
- }
32802
- }
32803
- }
32804
- namespace V2LeakedPasswordsPasswordHashPrefix {
32805
- namespace Get {
32806
- namespace Parameters {
32807
- type Path = {
32808
- passwordHashPrefix: string;
32809
- };
32810
- type Header = {};
32811
- type Query = {};
32812
- }
32813
- namespace Responses {
32814
- namespace $200 {
32815
+ namespace $404 {
32815
32816
  namespace Content {
32816
- type ApplicationJson = string[];
32817
+ interface ApplicationJson {
32818
+ [k: string]: unknown;
32819
+ }
32817
32820
  }
32818
32821
  }
32819
- namespace $400 {
32822
+ namespace $429 {
32820
32823
  namespace Content {
32821
32824
  interface ApplicationJson {
32822
32825
  [k: string]: unknown;
32823
32826
  }
32824
32827
  }
32825
32828
  }
32826
- namespace $429 {
32829
+ namespace $500 {
32827
32830
  namespace Content {
32828
32831
  interface ApplicationJson {
32829
32832
  [k: string]: unknown;
@@ -32839,29 +32842,24 @@ export declare namespace MittwaldAPIV2 {
32839
32842
  }
32840
32843
  }
32841
32844
  }
32842
- }
32843
- namespace V2ProjectsProjectIdDnsZoneImports {
32844
- namespace Get {
32845
+ namespace Patch {
32845
32846
  namespace Parameters {
32846
32847
  type Path = {
32847
- projectId: string;
32848
+ serverId: string;
32848
32849
  };
32850
+ interface RequestBody {
32851
+ notificationThresholdInBytes?: number;
32852
+ }
32849
32853
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
32850
- type Query = {
32851
- limit?: number;
32852
- skip?: number;
32853
- page?: number;
32854
- sort?: "createdAt";
32855
- order?: "asc" | "desc";
32856
- };
32854
+ type Query = {};
32857
32855
  }
32858
32856
  namespace Responses {
32859
- namespace $200 {
32857
+ namespace $204 {
32860
32858
  namespace Content {
32861
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.DnsZoneFileImport[];
32859
+ type Empty = unknown;
32862
32860
  }
32863
32861
  }
32864
- namespace $400 {
32862
+ namespace $403 {
32865
32863
  namespace Content {
32866
32864
  interface ApplicationJson {
32867
32865
  [k: string]: unknown;
@@ -32875,6 +32873,13 @@ export declare namespace MittwaldAPIV2 {
32875
32873
  }
32876
32874
  }
32877
32875
  }
32876
+ namespace $500 {
32877
+ namespace Content {
32878
+ interface ApplicationJson {
32879
+ [k: string]: unknown;
32880
+ }
32881
+ }
32882
+ }
32878
32883
  namespace Default {
32879
32884
  namespace Content {
32880
32885
  interface ApplicationJson {
@@ -32884,26 +32889,20 @@ export declare namespace MittwaldAPIV2 {
32884
32889
  }
32885
32890
  }
32886
32891
  }
32887
- namespace Post {
32892
+ }
32893
+ namespace V2ProjectsProjectIdStorageSpaceStatistics {
32894
+ namespace Get {
32888
32895
  namespace Parameters {
32889
32896
  type Path = {
32890
32897
  projectId: string;
32891
32898
  };
32892
- interface RequestBody {
32893
- /**
32894
- * Raw RFC-1035 zone file content to import.
32895
- */
32896
- zoneFile: string;
32897
- }
32898
32899
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
32899
- type Query = {
32900
- dryRun?: boolean;
32901
- };
32900
+ type Query = {};
32902
32901
  }
32903
32902
  namespace Responses {
32904
32903
  namespace $200 {
32905
32904
  namespace Content {
32906
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.DnsCreateZoneFileImportResponse;
32905
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.StoragespaceStatistics;
32907
32906
  }
32908
32907
  }
32909
32908
  namespace $400 {
@@ -32913,14 +32912,14 @@ export declare namespace MittwaldAPIV2 {
32913
32912
  }
32914
32913
  }
32915
32914
  }
32916
- namespace $404 {
32915
+ namespace $403 {
32917
32916
  namespace Content {
32918
32917
  interface ApplicationJson {
32919
32918
  [k: string]: unknown;
32920
32919
  }
32921
32920
  }
32922
32921
  }
32923
- namespace $412 {
32922
+ namespace $404 {
32924
32923
  namespace Content {
32925
32924
  interface ApplicationJson {
32926
32925
  [k: string]: unknown;
@@ -32934,6 +32933,13 @@ export declare namespace MittwaldAPIV2 {
32934
32933
  }
32935
32934
  }
32936
32935
  }
32936
+ namespace $500 {
32937
+ namespace Content {
32938
+ interface ApplicationJson {
32939
+ [k: string]: unknown;
32940
+ }
32941
+ }
32942
+ }
32937
32943
  namespace Default {
32938
32944
  namespace Content {
32939
32945
  interface ApplicationJson {
@@ -32943,37 +32949,38 @@ export declare namespace MittwaldAPIV2 {
32943
32949
  }
32944
32950
  }
32945
32951
  }
32946
- }
32947
- namespace V2DnsZoneImportsZoneFileImportId {
32948
- namespace Get {
32952
+ namespace Patch {
32949
32953
  namespace Parameters {
32950
32954
  type Path = {
32951
- zoneFileImportId: string;
32955
+ projectId: string;
32952
32956
  };
32957
+ interface RequestBody {
32958
+ notificationThresholdInBytes?: number;
32959
+ }
32953
32960
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
32954
32961
  type Query = {};
32955
32962
  }
32956
32963
  namespace Responses {
32957
- namespace $200 {
32964
+ namespace $204 {
32958
32965
  namespace Content {
32959
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.DnsZoneFileImport;
32966
+ type Empty = unknown;
32960
32967
  }
32961
32968
  }
32962
- namespace $400 {
32969
+ namespace $403 {
32963
32970
  namespace Content {
32964
32971
  interface ApplicationJson {
32965
32972
  [k: string]: unknown;
32966
32973
  }
32967
32974
  }
32968
32975
  }
32969
- namespace $404 {
32976
+ namespace $429 {
32970
32977
  namespace Content {
32971
32978
  interface ApplicationJson {
32972
32979
  [k: string]: unknown;
32973
32980
  }
32974
32981
  }
32975
32982
  }
32976
- namespace $429 {
32983
+ namespace $500 {
32977
32984
  namespace Content {
32978
32985
  interface ApplicationJson {
32979
32986
  [k: string]: unknown;
@@ -32990,5 +32997,6 @@ export declare namespace MittwaldAPIV2 {
32990
32997
  }
32991
32998
  }
32992
32999
  }
33000
+ namespace V2ServersServerIdStorageSpaceNotificationThreshold { }
32993
33001
  }
32994
33002
  }