@mittwald/api-client 4.473.0 → 4.474.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.
@@ -858,10 +858,6 @@ export declare namespace MittwaldAPIV2 {
858
858
  type RequestData = InferredRequestData<typeof descriptors.userUpdateAccount>;
859
859
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userUpdateAccount, TStatus>;
860
860
  }
861
- namespace DnsCreateDnsZone {
862
- type RequestData = InferredRequestData<typeof descriptors.dnsCreateDnsZone>;
863
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsCreateDnsZone, TStatus>;
864
- }
865
861
  namespace DnsGetDnsZone {
866
862
  type RequestData = InferredRequestData<typeof descriptors.dnsGetDnsZone>;
867
863
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsGetDnsZone, TStatus>;
@@ -878,6 +874,10 @@ export declare namespace MittwaldAPIV2 {
878
874
  type RequestData = InferredRequestData<typeof descriptors.dnsListDnsZones>;
879
875
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsListDnsZones, TStatus>;
880
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
881
  namespace DnsSetRecordSetManaged {
882
882
  type RequestData = InferredRequestData<typeof descriptors.dnsSetRecordSetManaged>;
883
883
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsSetRecordSetManaged, TStatus>;
@@ -1942,6 +1942,18 @@ export declare namespace MittwaldAPIV2 {
1942
1942
  type RequestData = InferredRequestData<typeof descriptors.userSearchedLeakedPasswordsByRange>;
1943
1943
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userSearchedLeakedPasswordsByRange, 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>;
1948
+ }
1949
+ namespace DnsCreateDnsZoneFileImport {
1950
+ type RequestData = InferredRequestData<typeof descriptors.dnsCreateDnsZoneFileImport>;
1951
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsCreateDnsZoneFileImport, TStatus>;
1952
+ }
1953
+ namespace DnsGetDnsZoneFileImport {
1954
+ type RequestData = InferredRequestData<typeof descriptors.dnsGetDnsZoneFileImport>;
1955
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.dnsGetDnsZoneFileImport, TStatus>;
1956
+ }
1945
1957
  }
1946
1958
  namespace Components {
1947
1959
  namespace Schemas {
@@ -7359,6 +7371,122 @@ export declare namespace MittwaldAPIV2 {
7359
7371
  }
7360
7372
  type VerificationEmailOrigin = "IS_MITTWALD" | "IS_NOT_MITTWALD" | "COULD_BE_MITTWALD";
7361
7373
  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
+ */
7396
+ 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;
7405
+ }
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";
7423
+ }
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;
7449
+ }
7450
+ interface DnsImportConflict {
7451
+ /**
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).
7453
+ */
7454
+ code: "parseError" | "invalidRecord" | "invalidZoneName" | "unsupportedRecordType" | "cnameConflict" | "foreignCustomerIngress" | "rootZoneUnavailable";
7455
+ /**
7456
+ * Human-readable explanation of the conflict, suitable for surfacing to the user.
7457
+ */
7458
+ message: string;
7459
+ /**
7460
+ * Offending record/owner name. Empty for a file-level parse error, where sourceLine locates the bad line.
7461
+ */
7462
+ name?: string;
7463
+ /**
7464
+ * Only on an invalidRecord conflict: the offending record's rendered value (e.g. "10 ." for an MX).
7465
+ */
7466
+ record?: string;
7467
+ /**
7468
+ * Only on an invalidRecord conflict: the offending record's set type.
7469
+ */
7470
+ recordSetType?: "a" | "mx" | "txt" | "cname" | "srv" | "caa";
7471
+ /**
7472
+ * 1-based line number in the uploaded zone file, set for a file-level parse error (code parseError); 0 otherwise.
7473
+ */
7474
+ sourceLine?: number;
7475
+ }
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";
7489
+ }
7362
7490
  interface CommonsAddress {
7363
7491
  street: string;
7364
7492
  houseNumber: string;
@@ -19015,23 +19143,21 @@ export declare namespace MittwaldAPIV2 {
19015
19143
  namespace V2SignupSessionsTokenId { }
19016
19144
  namespace V2SignupEmailVerify { }
19017
19145
  namespace V2DnsZones { }
19018
- namespace V2DnsZones {
19019
- namespace Post {
19146
+ namespace V2DnsZones { }
19147
+ namespace V2DnsZonesDnsZoneId { }
19148
+ namespace V2DnsZonesDnsZoneId {
19149
+ namespace Get {
19020
19150
  namespace Parameters {
19021
- type Path = {};
19022
- interface RequestBody {
19023
- name: string;
19024
- parentZoneId: string;
19025
- }
19151
+ type Path = {
19152
+ dnsZoneId: string;
19153
+ };
19026
19154
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
19027
19155
  type Query = {};
19028
19156
  }
19029
19157
  namespace Responses {
19030
- namespace $201 {
19158
+ namespace $200 {
19031
19159
  namespace Content {
19032
- interface ApplicationJson {
19033
- id: string;
19034
- }
19160
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.DnsZone;
19035
19161
  }
19036
19162
  }
19037
19163
  namespace $400 {
@@ -19041,13 +19167,6 @@ export declare namespace MittwaldAPIV2 {
19041
19167
  }
19042
19168
  }
19043
19169
  }
19044
- namespace $409 {
19045
- namespace Content {
19046
- interface ApplicationJson {
19047
- [k: string]: unknown;
19048
- }
19049
- }
19050
- }
19051
19170
  namespace $429 {
19052
19171
  namespace Content {
19053
19172
  interface ApplicationJson {
@@ -19064,10 +19183,7 @@ export declare namespace MittwaldAPIV2 {
19064
19183
  }
19065
19184
  }
19066
19185
  }
19067
- }
19068
- namespace V2DnsZonesDnsZoneId { }
19069
- namespace V2DnsZonesDnsZoneId {
19070
- namespace Get {
19186
+ namespace Delete {
19071
19187
  namespace Parameters {
19072
19188
  type Path = {
19073
19189
  dnsZoneId: string;
@@ -19076,9 +19192,9 @@ export declare namespace MittwaldAPIV2 {
19076
19192
  type Query = {};
19077
19193
  }
19078
19194
  namespace Responses {
19079
- namespace $200 {
19195
+ namespace $204 {
19080
19196
  namespace Content {
19081
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.DnsZone;
19197
+ type Empty = unknown;
19082
19198
  }
19083
19199
  }
19084
19200
  namespace $400 {
@@ -19104,7 +19220,9 @@ export declare namespace MittwaldAPIV2 {
19104
19220
  }
19105
19221
  }
19106
19222
  }
19107
- namespace Delete {
19223
+ }
19224
+ namespace V2DnsZonesDnsZoneIdZoneFile {
19225
+ namespace Get {
19108
19226
  namespace Parameters {
19109
19227
  type Path = {
19110
19228
  dnsZoneId: string;
@@ -19113,9 +19231,9 @@ export declare namespace MittwaldAPIV2 {
19113
19231
  type Query = {};
19114
19232
  }
19115
19233
  namespace Responses {
19116
- namespace $204 {
19234
+ namespace $200 {
19117
19235
  namespace Content {
19118
- type Empty = unknown;
19236
+ type TextPlain = string;
19119
19237
  }
19120
19238
  }
19121
19239
  namespace $400 {
@@ -19142,11 +19260,12 @@ export declare namespace MittwaldAPIV2 {
19142
19260
  }
19143
19261
  }
19144
19262
  }
19145
- namespace V2DnsZonesDnsZoneIdZoneFile {
19263
+ namespace V2ProjectsProjectIdDnsZones { }
19264
+ namespace V2ProjectsProjectIdDnsZones {
19146
19265
  namespace Get {
19147
19266
  namespace Parameters {
19148
19267
  type Path = {
19149
- dnsZoneId: string;
19268
+ projectId: string;
19150
19269
  };
19151
19270
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
19152
19271
  type Query = {};
@@ -19154,7 +19273,7 @@ export declare namespace MittwaldAPIV2 {
19154
19273
  namespace Responses {
19155
19274
  namespace $200 {
19156
19275
  namespace Content {
19157
- type TextPlain = string;
19276
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.DnsZone[];
19158
19277
  }
19159
19278
  }
19160
19279
  namespace $400 {
@@ -19180,21 +19299,26 @@ export declare namespace MittwaldAPIV2 {
19180
19299
  }
19181
19300
  }
19182
19301
  }
19183
- }
19184
- namespace V2ProjectsProjectIdDnsZones { }
19185
- namespace V2ProjectsProjectIdDnsZones {
19186
- namespace Get {
19302
+ namespace Post {
19187
19303
  namespace Parameters {
19188
19304
  type Path = {
19189
19305
  projectId: string;
19190
19306
  };
19307
+ interface RequestBody {
19308
+ /**
19309
+ * Fully-qualified name of the DNSZone to create (e.g. example.com or _autoconfig.example.com). The backend resolves root vs subzone via the public suffix list.
19310
+ */
19311
+ name: string;
19312
+ }
19191
19313
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
19192
19314
  type Query = {};
19193
19315
  }
19194
19316
  namespace Responses {
19195
- namespace $200 {
19317
+ namespace $201 {
19196
19318
  namespace Content {
19197
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.DnsZone[];
19319
+ interface ApplicationJson {
19320
+ id: string;
19321
+ }
19198
19322
  }
19199
19323
  }
19200
19324
  namespace $400 {
@@ -19204,6 +19328,27 @@ export declare namespace MittwaldAPIV2 {
19204
19328
  }
19205
19329
  }
19206
19330
  }
19331
+ namespace $404 {
19332
+ namespace Content {
19333
+ interface ApplicationJson {
19334
+ [k: string]: unknown;
19335
+ }
19336
+ }
19337
+ }
19338
+ namespace $409 {
19339
+ namespace Content {
19340
+ interface ApplicationJson {
19341
+ [k: string]: unknown;
19342
+ }
19343
+ }
19344
+ }
19345
+ namespace $412 {
19346
+ namespace Content {
19347
+ interface ApplicationJson {
19348
+ [k: string]: unknown;
19349
+ }
19350
+ }
19351
+ }
19207
19352
  namespace $429 {
19208
19353
  namespace Content {
19209
19354
  interface ApplicationJson {
@@ -32695,5 +32840,155 @@ export declare namespace MittwaldAPIV2 {
32695
32840
  }
32696
32841
  }
32697
32842
  }
32843
+ namespace V2ProjectsProjectIdDnsZoneImports {
32844
+ namespace Get {
32845
+ namespace Parameters {
32846
+ type Path = {
32847
+ projectId: string;
32848
+ };
32849
+ 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
+ };
32857
+ }
32858
+ namespace Responses {
32859
+ namespace $200 {
32860
+ namespace Content {
32861
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.DnsZoneFileImport[];
32862
+ }
32863
+ }
32864
+ namespace $400 {
32865
+ namespace Content {
32866
+ interface ApplicationJson {
32867
+ [k: string]: unknown;
32868
+ }
32869
+ }
32870
+ }
32871
+ namespace $429 {
32872
+ namespace Content {
32873
+ interface ApplicationJson {
32874
+ [k: string]: unknown;
32875
+ }
32876
+ }
32877
+ }
32878
+ namespace Default {
32879
+ namespace Content {
32880
+ interface ApplicationJson {
32881
+ [k: string]: unknown;
32882
+ }
32883
+ }
32884
+ }
32885
+ }
32886
+ }
32887
+ namespace Post {
32888
+ namespace Parameters {
32889
+ type Path = {
32890
+ projectId: string;
32891
+ };
32892
+ interface RequestBody {
32893
+ /**
32894
+ * Raw RFC-1035 zone file content to import.
32895
+ */
32896
+ zoneFile: string;
32897
+ }
32898
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
32899
+ type Query = {
32900
+ dryRun?: boolean;
32901
+ };
32902
+ }
32903
+ namespace Responses {
32904
+ namespace $200 {
32905
+ namespace Content {
32906
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.DnsCreateZoneFileImportResponse;
32907
+ }
32908
+ }
32909
+ namespace $400 {
32910
+ namespace Content {
32911
+ interface ApplicationJson {
32912
+ [k: string]: unknown;
32913
+ }
32914
+ }
32915
+ }
32916
+ namespace $404 {
32917
+ namespace Content {
32918
+ interface ApplicationJson {
32919
+ [k: string]: unknown;
32920
+ }
32921
+ }
32922
+ }
32923
+ namespace $412 {
32924
+ namespace Content {
32925
+ interface ApplicationJson {
32926
+ [k: string]: unknown;
32927
+ }
32928
+ }
32929
+ }
32930
+ namespace $429 {
32931
+ namespace Content {
32932
+ interface ApplicationJson {
32933
+ [k: string]: unknown;
32934
+ }
32935
+ }
32936
+ }
32937
+ namespace Default {
32938
+ namespace Content {
32939
+ interface ApplicationJson {
32940
+ [k: string]: unknown;
32941
+ }
32942
+ }
32943
+ }
32944
+ }
32945
+ }
32946
+ }
32947
+ namespace V2DnsZoneImportsZoneFileImportId {
32948
+ namespace Get {
32949
+ namespace Parameters {
32950
+ type Path = {
32951
+ zoneFileImportId: string;
32952
+ };
32953
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
32954
+ type Query = {};
32955
+ }
32956
+ namespace Responses {
32957
+ namespace $200 {
32958
+ namespace Content {
32959
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.DnsZoneFileImport;
32960
+ }
32961
+ }
32962
+ namespace $400 {
32963
+ namespace Content {
32964
+ interface ApplicationJson {
32965
+ [k: string]: unknown;
32966
+ }
32967
+ }
32968
+ }
32969
+ namespace $404 {
32970
+ namespace Content {
32971
+ interface ApplicationJson {
32972
+ [k: string]: unknown;
32973
+ }
32974
+ }
32975
+ }
32976
+ namespace $429 {
32977
+ namespace Content {
32978
+ interface ApplicationJson {
32979
+ [k: string]: unknown;
32980
+ }
32981
+ }
32982
+ }
32983
+ namespace Default {
32984
+ namespace Content {
32985
+ interface ApplicationJson {
32986
+ [k: string]: unknown;
32987
+ }
32988
+ }
32989
+ }
32990
+ }
32991
+ }
32992
+ }
32698
32993
  }
32699
32994
  }
@@ -2652,6 +2652,40 @@ declare const buildDomainApi: (baseClient: MittwaldAPIV3NextClient) => {
2652
2652
  ingressId?: string | undefined;
2653
2653
  } | undefined;
2654
2654
  } | null | undefined) => import("@mittwald/react-use-promise").AsyncResource<import("./types.js").MittwaldAPIV3Next.Components.Schemas.DeMittwaldSslCertificate[]>;
2655
+ /** List DNS zone-file import jobs belonging to a Project. */
2656
+ dnsListDnsZoneFileImports: (conf: {
2657
+ projectId: string;
2658
+ headers?: {
2659
+ [x: string]: (string | number | boolean | Date) | (string | number | boolean | Date)[] | undefined;
2660
+ "x-access-token"?: string | undefined;
2661
+ } | undefined;
2662
+ queryParameters?: {
2663
+ [x: string]: (string | number | boolean | Date) | (string | number | boolean | Date)[] | undefined;
2664
+ limit?: number | undefined;
2665
+ skip?: number | undefined;
2666
+ page?: number | undefined;
2667
+ sort?: "createdAt" | undefined;
2668
+ order?: "asc" | "desc" | undefined;
2669
+ } | undefined;
2670
+ }) => import("@mittwald/react-use-promise").AsyncResource<import("./types.js").MittwaldAPIV3Next.Components.Schemas.DeMittwaldDnsZoneFileImport[]>;
2671
+ /** Get the status of a DNS zone-file import job. */
2672
+ dnsGetDnsZoneFileImport: (conf: {
2673
+ zoneFileImportId: string;
2674
+ headers?: {
2675
+ [x: string]: (string | number | boolean | Date) | (string | number | boolean | Date)[] | undefined;
2676
+ "x-access-token"?: string | undefined;
2677
+ } | undefined;
2678
+ }) => import("@mittwald/react-use-promise").AsyncResource<{
2679
+ createdAt: string;
2680
+ id: string;
2681
+ importedZones: string[];
2682
+ projectId: string;
2683
+ skippedZones: {
2684
+ name: string;
2685
+ reason: string;
2686
+ }[];
2687
+ status: "running" | "succeeded" | "completedWithErrors";
2688
+ }>;
2655
2689
  };
2656
2690
  declare const buildFileApi: (baseClient: MittwaldAPIV3NextClient) => {
2657
2691
  /** Get a File's meta. */