@mittwald/api-client 4.524.0 → 4.525.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.
@@ -1238,62 +1238,6 @@ export declare namespace MittwaldAPIV2 {
1238
1238
  type RequestData = InferredRequestData<typeof descriptors.invoiceListCustomerInvoices>;
1239
1239
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.invoiceListCustomerInvoices, TStatus>;
1240
1240
  }
1241
- namespace LeadfyndrGetLeadFyndrProfileRequest {
1242
- type RequestData = InferredRequestData<typeof descriptors.leadfyndrGetLeadFyndrProfileRequest>;
1243
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.leadfyndrGetLeadFyndrProfileRequest, TStatus>;
1244
- }
1245
- namespace LeadfyndrCreateLeadFyndrAccessRequest {
1246
- type RequestData = InferredRequestData<typeof descriptors.leadfyndrCreateLeadFyndrAccessRequest>;
1247
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.leadfyndrCreateLeadFyndrAccessRequest, TStatus>;
1248
- }
1249
- namespace LeadfyndrCreateLeadsExport {
1250
- type RequestData = InferredRequestData<typeof descriptors.leadfyndrCreateLeadsExport>;
1251
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.leadfyndrCreateLeadsExport, TStatus>;
1252
- }
1253
- namespace LeadfyndrGetCities {
1254
- type RequestData = InferredRequestData<typeof descriptors.leadfyndrGetCities>;
1255
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.leadfyndrGetCities, TStatus>;
1256
- }
1257
- namespace LeadfyndrGetLeadFyndrProfileTariffOptions {
1258
- type RequestData = InferredRequestData<typeof descriptors.leadfyndrGetLeadFyndrProfileTariffOptions>;
1259
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.leadfyndrGetLeadFyndrProfileTariffOptions, TStatus>;
1260
- }
1261
- namespace LeadfyndrGetLeadFyndrProfile {
1262
- type RequestData = InferredRequestData<typeof descriptors.leadfyndrGetLeadFyndrProfile>;
1263
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.leadfyndrGetLeadFyndrProfile, TStatus>;
1264
- }
1265
- namespace LeadfyndrGetLead {
1266
- type RequestData = InferredRequestData<typeof descriptors.leadfyndrGetLead>;
1267
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.leadfyndrGetLead, TStatus>;
1268
- }
1269
- namespace LeadfyndrGetLeadsExportHistory {
1270
- type RequestData = InferredRequestData<typeof descriptors.leadfyndrGetLeadsExportHistory>;
1271
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.leadfyndrGetLeadsExportHistory, TStatus>;
1272
- }
1273
- namespace LeadfyndrGetUnlockedLead {
1274
- type RequestData = InferredRequestData<typeof descriptors.leadfyndrGetUnlockedLead>;
1275
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.leadfyndrGetUnlockedLead, TStatus>;
1276
- }
1277
- namespace LeadfyndrUnlockLead {
1278
- type RequestData = InferredRequestData<typeof descriptors.leadfyndrUnlockLead>;
1279
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.leadfyndrUnlockLead, TStatus>;
1280
- }
1281
- namespace LeadfyndrListLeads {
1282
- type RequestData = InferredRequestData<typeof descriptors.leadfyndrListLeads>;
1283
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.leadfyndrListLeads, TStatus>;
1284
- }
1285
- namespace LeadfyndrListUnlockedLeads {
1286
- type RequestData = InferredRequestData<typeof descriptors.leadfyndrListUnlockedLeads>;
1287
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.leadfyndrListUnlockedLeads, TStatus>;
1288
- }
1289
- namespace LeadfyndrReserveUnlockedLead {
1290
- type RequestData = InferredRequestData<typeof descriptors.leadfyndrReserveUnlockedLead>;
1291
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.leadfyndrReserveUnlockedLead, TStatus>;
1292
- }
1293
- namespace LeadfyndrRemoveUnlockedLeadReservation {
1294
- type RequestData = InferredRequestData<typeof descriptors.leadfyndrRemoveUnlockedLeadReservation>;
1295
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.leadfyndrRemoveUnlockedLeadReservation, TStatus>;
1296
- }
1297
1241
  namespace LicenseGetLicense {
1298
1242
  type RequestData = InferredRequestData<typeof descriptors.licenseGetLicense>;
1299
1243
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.licenseGetLicense, TStatus>;
@@ -2006,6 +1950,10 @@ export declare namespace MittwaldAPIV2 {
2006
1950
  type RequestData = InferredRequestData<typeof descriptors.verificationVerifyCompany>;
2007
1951
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.verificationVerifyCompany, TStatus>;
2008
1952
  }
1953
+ namespace DomainCheckAuthinfo2 {
1954
+ type RequestData = InferredRequestData<typeof descriptors.domainCheckAuthinfo2>;
1955
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainCheckAuthinfo2, TStatus>;
1956
+ }
2009
1957
  }
2010
1958
  namespace Components {
2011
1959
  namespace Schemas {
@@ -5561,172 +5509,6 @@ export declare namespace MittwaldAPIV2 {
5561
5509
  title?: string;
5562
5510
  useFormalTerm?: boolean;
5563
5511
  }
5564
- interface LeadfyndrBasicCompany {
5565
- county: string;
5566
- employeeCount?: number;
5567
- foundingYear?: number;
5568
- salesVolume?: number;
5569
- }
5570
- interface LeadfyndrBasicMetrics {
5571
- co2?: number;
5572
- contentLoaded?: number;
5573
- desktop: MittwaldAPIV2.Components.Schemas.LeadfyndrLighthouse;
5574
- mobile: MittwaldAPIV2.Components.Schemas.LeadfyndrLighthouse;
5575
- timeToFirstByteMs?: number;
5576
- }
5577
- interface LeadfyndrCity {
5578
- city: string;
5579
- country: string;
5580
- county?: string;
5581
- postCode: string;
5582
- }
5583
- interface LeadfyndrContact {
5584
- address?: {
5585
- addressPrefix?: string;
5586
- city?: string;
5587
- countryCode?: string;
5588
- houseNumber?: string;
5589
- street?: string;
5590
- zip?: string;
5591
- };
5592
- }
5593
- type LeadfyndrDetailCompany = MittwaldAPIV2.Components.Schemas.LeadfyndrBasicCompany & {
5594
- city: string;
5595
- companyType: string[];
5596
- coreProduct: string[];
5597
- name?: string;
5598
- phoneNumbers: string[];
5599
- targetGroup: string[];
5600
- websiteType: string[];
5601
- };
5602
- interface LeadfyndrDetailMetrics {
5603
- additionalMetrics?: {
5604
- [k: string]: MittwaldAPIV2.Components.Schemas.LeadfyndrMetric;
5605
- };
5606
- basic: MittwaldAPIV2.Components.Schemas.LeadfyndrBasicMetrics;
5607
- }
5608
- interface LeadfyndrHoster {
5609
- mailServer: string[];
5610
- nameServer: string[];
5611
- server: string[];
5612
- }
5613
- interface LeadfyndrLead {
5614
- businessFields: string[];
5615
- company: MittwaldAPIV2.Components.Schemas.LeadfyndrBasicCompany;
5616
- description: string;
5617
- hoster: {
5618
- server: string[];
5619
- };
5620
- languages: string[];
5621
- leadId: string;
5622
- mainTechnology?: MittwaldAPIV2.Components.Schemas.LeadfyndrTechnology;
5623
- metrics: MittwaldAPIV2.Components.Schemas.LeadfyndrBasicMetrics;
5624
- potential: number;
5625
- scannedAt?: string;
5626
- screenshot: string;
5627
- technologies: MittwaldAPIV2.Components.Schemas.LeadfyndrTechnology[];
5628
- }
5629
- interface LeadfyndrTariffOptions {
5630
- nextUnlockRenewalDate?: string;
5631
- reservation: {
5632
- available: number;
5633
- tariffLimit: number;
5634
- used: number;
5635
- };
5636
- unlocked: {
5637
- available: number;
5638
- tariffLimit: number;
5639
- used: number;
5640
- };
5641
- }
5642
- interface LeadfyndrLeadsExport {
5643
- customerId: string;
5644
- exportId: string;
5645
- exportedAt: string;
5646
- exportedBy?: MittwaldAPIV2.Components.Schemas.LeadfyndrLeadsExportExporter;
5647
- /**
5648
- * The number of leads included in the export.
5649
- */
5650
- leadCount: number;
5651
- }
5652
- interface LeadfyndrLeadsExportExporter {
5653
- avatarRefId?: string;
5654
- person?: {
5655
- firstName: string;
5656
- lastName: string;
5657
- };
5658
- userId: string;
5659
- }
5660
- interface LeadfyndrLighthouse {
5661
- accessibility?: number;
5662
- bestPractice?: number;
5663
- cumulativeLayoutShift?: number;
5664
- firstContentfulPaint?: number;
5665
- largestContentfulPaint?: number;
5666
- performance?: number;
5667
- seo?: number;
5668
- totalBlockingTime?: number;
5669
- }
5670
- interface LeadfyndrMetric {
5671
- category: string;
5672
- name: string;
5673
- score?: number;
5674
- unit?: string;
5675
- value?: number;
5676
- }
5677
- interface LeadfyndrProfileRequest {
5678
- createdOn: string;
5679
- customerId: string;
5680
- domain: string;
5681
- profileId: string;
5682
- requestedBy: MittwaldAPIV2.Components.Schemas.LeadfyndrUser;
5683
- resultOn?: string;
5684
- status: "AUTOTEST_INIT" | "MANUAL_VERIFICATION" | "REJECTED" | "APPROVED";
5685
- }
5686
- interface LeadfyndrProfile {
5687
- approvedOn: string;
5688
- customerId: string;
5689
- disabledOn?: string;
5690
- domain: string;
5691
- }
5692
- interface LeadfyndrSocialMedia {
5693
- network: string;
5694
- url: string;
5695
- }
5696
- interface LeadfyndrTechnology {
5697
- categories?: {
5698
- name: string;
5699
- parentCategories?: string[];
5700
- priority: number;
5701
- }[];
5702
- categoryPriority: number;
5703
- name: string;
5704
- version?: string;
5705
- }
5706
- interface LeadfyndrUnlockedLead {
5707
- actualUrl: string;
5708
- businessFields: string[];
5709
- company: MittwaldAPIV2.Components.Schemas.LeadfyndrDetailCompany;
5710
- contact: MittwaldAPIV2.Components.Schemas.LeadfyndrContact;
5711
- description: string;
5712
- domain: string;
5713
- hoster: MittwaldAPIV2.Components.Schemas.LeadfyndrHoster;
5714
- languages: string[];
5715
- leadId: string;
5716
- mainTechnology?: MittwaldAPIV2.Components.Schemas.LeadfyndrTechnology;
5717
- metrics: MittwaldAPIV2.Components.Schemas.LeadfyndrDetailMetrics;
5718
- potential: number;
5719
- reservationAllowed?: boolean;
5720
- reservedAt?: string;
5721
- scannedAt?: string;
5722
- screenshot: string;
5723
- socialMedia: MittwaldAPIV2.Components.Schemas.LeadfyndrSocialMedia[];
5724
- technologies: MittwaldAPIV2.Components.Schemas.LeadfyndrTechnology[];
5725
- unlockedAt: string;
5726
- }
5727
- interface LeadfyndrUser {
5728
- userId: string;
5729
- }
5730
5512
  interface LicenseAppVersionMeta {
5731
5513
  description: string;
5732
5514
  }
@@ -25867,21 +25649,19 @@ export declare namespace MittwaldAPIV2 {
25867
25649
  }
25868
25650
  }
25869
25651
  }
25870
- namespace ExperimentalV2CustomersCustomerIdLeadFyndrProfileRequest { }
25871
- namespace V2ExperimentalCustomersCustomerIdLeadFyndrProfileRequest { }
25872
- namespace V2CustomersCustomerIdLeadFyndrProfileRequest {
25652
+ namespace V2LicensesLicenseId {
25873
25653
  namespace Get {
25874
25654
  namespace Parameters {
25875
25655
  type Path = {
25876
- customerId: string;
25656
+ licenseId: string;
25877
25657
  };
25878
- type Header = {};
25658
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
25879
25659
  type Query = {};
25880
25660
  }
25881
25661
  namespace Responses {
25882
25662
  namespace $200 {
25883
25663
  namespace Content {
25884
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LeadfyndrProfileRequest;
25664
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.LicenseLicense;
25885
25665
  }
25886
25666
  }
25887
25667
  namespace $400 {
@@ -25898,7 +25678,57 @@ export declare namespace MittwaldAPIV2 {
25898
25678
  }
25899
25679
  }
25900
25680
  }
25901
- namespace $404 {
25681
+ namespace $429 {
25682
+ namespace Content {
25683
+ interface ApplicationJson {
25684
+ [k: string]: unknown;
25685
+ }
25686
+ }
25687
+ }
25688
+ namespace $500 {
25689
+ namespace Content {
25690
+ interface ApplicationJson {
25691
+ [k: string]: unknown;
25692
+ }
25693
+ }
25694
+ }
25695
+ namespace Default {
25696
+ namespace Content {
25697
+ interface ApplicationJson {
25698
+ [k: string]: unknown;
25699
+ }
25700
+ }
25701
+ }
25702
+ }
25703
+ }
25704
+ }
25705
+ namespace V2ProjectsProjectIdLicenses {
25706
+ namespace Get {
25707
+ namespace Parameters {
25708
+ type Path = {
25709
+ projectId: string;
25710
+ };
25711
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
25712
+ type Query = {
25713
+ limit?: number;
25714
+ skip?: number;
25715
+ page?: number;
25716
+ };
25717
+ }
25718
+ namespace Responses {
25719
+ namespace $200 {
25720
+ namespace Content {
25721
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.LicenseLicense[];
25722
+ }
25723
+ }
25724
+ namespace $400 {
25725
+ namespace Content {
25726
+ interface ApplicationJson {
25727
+ [k: string]: unknown;
25728
+ }
25729
+ }
25730
+ }
25731
+ namespace $403 {
25902
25732
  namespace Content {
25903
25733
  interface ApplicationJson {
25904
25734
  [k: string]: unknown;
@@ -25912,6 +25742,13 @@ export declare namespace MittwaldAPIV2 {
25912
25742
  }
25913
25743
  }
25914
25744
  }
25745
+ namespace $500 {
25746
+ namespace Content {
25747
+ interface ApplicationJson {
25748
+ [k: string]: unknown;
25749
+ }
25750
+ }
25751
+ }
25915
25752
  namespace Default {
25916
25753
  namespace Content {
25917
25754
  interface ApplicationJson {
@@ -25921,23 +25758,26 @@ export declare namespace MittwaldAPIV2 {
25921
25758
  }
25922
25759
  }
25923
25760
  }
25761
+ }
25762
+ namespace V2LicensesLicenseIdActionsRotateKey {
25924
25763
  namespace Post {
25925
25764
  namespace Parameters {
25926
25765
  type Path = {
25927
- customerId: string;
25766
+ licenseId: string;
25928
25767
  };
25768
+ /**
25769
+ * Optional reference to a file containing the new key if it was not procured via mittwald.
25770
+ */
25929
25771
  interface RequestBody {
25930
- domain: string;
25772
+ externalKey?: string;
25931
25773
  }
25932
- type Header = {};
25774
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
25933
25775
  type Query = {};
25934
25776
  }
25935
25777
  namespace Responses {
25936
- namespace $201 {
25778
+ namespace $200 {
25937
25779
  namespace Content {
25938
- interface ApplicationJson {
25939
- profileId: string;
25940
- }
25780
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.LicenseKeyResponse;
25941
25781
  }
25942
25782
  }
25943
25783
  namespace $400 {
@@ -25961,7 +25801,7 @@ export declare namespace MittwaldAPIV2 {
25961
25801
  }
25962
25802
  }
25963
25803
  }
25964
- namespace $409 {
25804
+ namespace $412 {
25965
25805
  namespace Content {
25966
25806
  interface ApplicationJson {
25967
25807
  [k: string]: unknown;
@@ -25975,6 +25815,13 @@ export declare namespace MittwaldAPIV2 {
25975
25815
  }
25976
25816
  }
25977
25817
  }
25818
+ namespace $500 {
25819
+ namespace Content {
25820
+ interface ApplicationJson {
25821
+ [k: string]: unknown;
25822
+ }
25823
+ }
25824
+ }
25978
25825
  namespace Default {
25979
25826
  namespace Content {
25980
25827
  interface ApplicationJson {
@@ -25985,41 +25832,28 @@ export declare namespace MittwaldAPIV2 {
25985
25832
  }
25986
25833
  }
25987
25834
  }
25988
- namespace ExperimentalV2CustomersCustomerIdUnlockedLeadsExport { }
25989
- namespace V2ExperimentalCustomersCustomerIdUnlockedLeadsExport { }
25990
- namespace V2CustomersCustomerIdUnlockedLeadsExport {
25835
+ namespace V2ProjectsProjectIdActionsValidateLicenseKey {
25991
25836
  namespace Post {
25992
25837
  namespace Parameters {
25993
25838
  type Path = {
25994
- customerId: string;
25839
+ projectId: string;
25995
25840
  };
25841
+ /**
25842
+ * The License key to validate.
25843
+ */
25996
25844
  interface RequestBody {
25997
- /**
25998
- * Whether to export all leads or only not already exported leads.
25999
- */
26000
- exportAllLeads: boolean;
26001
- /**
26002
- * The fields to include in the export.
26003
- */
26004
- fieldKeys: ("domain" | "potential" | "performance" | "generalLook" | "companyName" | "emails" | "phoneNumbers" | "address" | "employeeCount" | "revenue" | "a-record" | "nameserver" | "mailserver" | "techStack")[];
25845
+ key: string;
25846
+ kind: MittwaldAPIV2.Components.Schemas.LicenseKind;
26005
25847
  }
26006
- type Header = {};
25848
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26007
25849
  type Query = {};
26008
25850
  }
26009
25851
  namespace Responses {
26010
25852
  namespace $200 {
26011
25853
  namespace Content {
26012
25854
  interface ApplicationJson {
26013
- /**
26014
- * The base64 encoded csv content of the export.
26015
- */
26016
- contentBase64: string;
26017
- exportId: string;
25855
+ valid: boolean;
26018
25856
  }
26019
- /**
26020
- * The csv content of the export.
26021
- */
26022
- type TextCsv = string;
26023
25857
  }
26024
25858
  }
26025
25859
  namespace $400 {
@@ -26043,7 +25877,7 @@ export declare namespace MittwaldAPIV2 {
26043
25877
  }
26044
25878
  }
26045
25879
  }
26046
- namespace $409 {
25880
+ namespace $412 {
26047
25881
  namespace Content {
26048
25882
  interface ApplicationJson {
26049
25883
  [k: string]: unknown;
@@ -26057,6 +25891,13 @@ export declare namespace MittwaldAPIV2 {
26057
25891
  }
26058
25892
  }
26059
25893
  }
25894
+ namespace $500 {
25895
+ namespace Content {
25896
+ interface ApplicationJson {
25897
+ [k: string]: unknown;
25898
+ }
25899
+ }
25900
+ }
26060
25901
  namespace Default {
26061
25902
  namespace Content {
26062
25903
  interface ApplicationJson {
@@ -26067,21 +25908,25 @@ export declare namespace MittwaldAPIV2 {
26067
25908
  }
26068
25909
  }
26069
25910
  }
26070
- namespace ExperimentalV2Cities { }
26071
- namespace V2ExperimentalCities { }
26072
- namespace V2Cities {
25911
+ namespace V2ProjectsProjectIdDeliveryboxes { }
25912
+ namespace V2ProjectsProjectIdDeliveryBoxes {
26073
25913
  namespace Get {
26074
25914
  namespace Parameters {
26075
- type Path = {};
26076
- type Header = {};
25915
+ type Path = {
25916
+ projectId: string;
25917
+ };
25918
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26077
25919
  type Query = {
26078
- input: string;
25920
+ search?: string;
25921
+ limit?: number;
25922
+ skip?: number;
25923
+ page?: number;
26079
25924
  };
26080
25925
  }
26081
25926
  namespace Responses {
26082
25927
  namespace $200 {
26083
25928
  namespace Content {
26084
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LeadfyndrCity[];
25929
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailDeliverybox[];
26085
25930
  }
26086
25931
  }
26087
25932
  namespace $400 {
@@ -26112,6 +25957,20 @@ export declare namespace MittwaldAPIV2 {
26112
25957
  }
26113
25958
  }
26114
25959
  }
25960
+ namespace $500 {
25961
+ namespace Content {
25962
+ interface ApplicationJson {
25963
+ [k: string]: unknown;
25964
+ }
25965
+ }
25966
+ }
25967
+ namespace $503 {
25968
+ namespace Content {
25969
+ interface ApplicationJson {
25970
+ [k: string]: unknown;
25971
+ }
25972
+ }
25973
+ }
26115
25974
  namespace Default {
26116
25975
  namespace Content {
26117
25976
  interface ApplicationJson {
@@ -26121,22 +25980,27 @@ export declare namespace MittwaldAPIV2 {
26121
25980
  }
26122
25981
  }
26123
25982
  }
26124
- }
26125
- namespace ExperimentalV2CustomersCustomerIdLeadFyndrProfileTariff { }
26126
- namespace V2ExperimentalCustomersCustomerIdLeadFyndrProfileTariff { }
26127
- namespace V2CustomersCustomerIdLeadFyndrProfileTariff {
26128
- namespace Get {
25983
+ namespace Post {
26129
25984
  namespace Parameters {
26130
25985
  type Path = {
26131
- customerId: string;
25986
+ projectId: string;
26132
25987
  };
26133
- type Header = {};
25988
+ interface RequestBody {
25989
+ description: string;
25990
+ /**
25991
+ * Password of the Deliverybox. Write-only: it is never returned by any route.
25992
+ */
25993
+ password: string;
25994
+ }
25995
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26134
25996
  type Query = {};
26135
25997
  }
26136
25998
  namespace Responses {
26137
- namespace $200 {
25999
+ namespace $201 {
26138
26000
  namespace Content {
26139
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LeadfyndrTariffOptions;
26001
+ interface ApplicationJson {
26002
+ id: string;
26003
+ }
26140
26004
  }
26141
26005
  }
26142
26006
  namespace $400 {
@@ -26167,6 +26031,20 @@ export declare namespace MittwaldAPIV2 {
26167
26031
  }
26168
26032
  }
26169
26033
  }
26034
+ namespace $500 {
26035
+ namespace Content {
26036
+ interface ApplicationJson {
26037
+ [k: string]: unknown;
26038
+ }
26039
+ }
26040
+ }
26041
+ namespace $503 {
26042
+ namespace Content {
26043
+ interface ApplicationJson {
26044
+ [k: string]: unknown;
26045
+ }
26046
+ }
26047
+ }
26170
26048
  namespace Default {
26171
26049
  namespace Content {
26172
26050
  interface ApplicationJson {
@@ -26177,23 +26055,31 @@ export declare namespace MittwaldAPIV2 {
26177
26055
  }
26178
26056
  }
26179
26057
  }
26180
- namespace ExperimentalV2CustomersCustomerIdLeadFyndrProfile { }
26181
- namespace V2ExperimentalCustomersCustomerIdLeadFyndrProfile { }
26182
- namespace V2CustomersCustomerIdLeadFyndrProfile {
26058
+ namespace V2ProjectsProjectIdMailaddresses { }
26059
+ namespace V2ProjectsProjectIdMailAddresses {
26183
26060
  namespace Get {
26184
26061
  namespace Parameters {
26185
26062
  type Path = {
26186
- customerId: string;
26063
+ projectId: string;
26064
+ };
26065
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26066
+ type Query = {
26067
+ search?: string;
26068
+ forwardAddress?: boolean;
26069
+ catchAll?: boolean;
26070
+ autoResponder?: boolean;
26071
+ mailArchive?: boolean;
26072
+ limit?: number;
26073
+ skip?: number;
26074
+ page?: number;
26075
+ sort?: ("address.domain" | "address.local" | "updatedAt" | "projectId" | "mailbox.quota" | "mailbox.name" | "mailbox.storageInBytes.current" | "mailbox.storageInBytes.limit")[];
26076
+ order?: ("asc" | "desc")[];
26187
26077
  };
26188
- type Header = {};
26189
- type Query = {};
26190
26078
  }
26191
26079
  namespace Responses {
26192
26080
  namespace $200 {
26193
26081
  namespace Content {
26194
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LeadfyndrProfile & {
26195
- tariff: MittwaldAPIV2.Components.Schemas.LeadfyndrTariffOptions;
26196
- };
26082
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailMailAddress[];
26197
26083
  }
26198
26084
  }
26199
26085
  namespace $400 {
@@ -26224,117 +26110,82 @@ export declare namespace MittwaldAPIV2 {
26224
26110
  }
26225
26111
  }
26226
26112
  }
26227
- namespace Default {
26113
+ namespace $500 {
26228
26114
  namespace Content {
26229
26115
  interface ApplicationJson {
26230
26116
  [k: string]: unknown;
26231
26117
  }
26232
26118
  }
26233
26119
  }
26234
- }
26235
- }
26236
- }
26237
- namespace ExperimentalV2CustomersCustomerIdLeadsLeadId { }
26238
- namespace V2ExperimentalCustomersCustomerIdLeadsLeadId { }
26239
- namespace V2CustomersCustomerIdLeadsLeadId {
26240
- namespace Get {
26241
- namespace Parameters {
26242
- type Path = {
26243
- leadId: string;
26244
- customerId: string;
26245
- };
26246
- type Header = {};
26247
- type Query = {};
26248
- }
26249
- namespace Responses {
26250
- namespace $200 {
26251
- namespace Content {
26252
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LeadfyndrLead;
26253
- }
26254
- }
26255
- namespace $400 {
26120
+ namespace $503 {
26256
26121
  namespace Content {
26257
26122
  interface ApplicationJson {
26258
26123
  [k: string]: unknown;
26259
26124
  }
26260
26125
  }
26261
26126
  }
26262
- namespace $403 {
26127
+ namespace Default {
26263
26128
  namespace Content {
26264
26129
  interface ApplicationJson {
26265
26130
  [k: string]: unknown;
26266
26131
  }
26267
26132
  }
26268
26133
  }
26269
- namespace $404 {
26134
+ }
26135
+ }
26136
+ namespace Post {
26137
+ namespace Parameters {
26138
+ type Path = {
26139
+ projectId: string;
26140
+ };
26141
+ type RequestBody = MittwaldAPIV2.Components.Schemas.MailCreateForwardAddress | MittwaldAPIV2.Components.Schemas.MailCreateMailAddress;
26142
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26143
+ type Query = {};
26144
+ }
26145
+ namespace Responses {
26146
+ namespace $201 {
26270
26147
  namespace Content {
26271
26148
  interface ApplicationJson {
26272
- [k: string]: unknown;
26149
+ id: string;
26273
26150
  }
26274
26151
  }
26275
26152
  }
26276
- namespace $429 {
26153
+ namespace $400 {
26277
26154
  namespace Content {
26278
26155
  interface ApplicationJson {
26279
26156
  [k: string]: unknown;
26280
26157
  }
26281
26158
  }
26282
26159
  }
26283
- namespace Default {
26160
+ namespace $403 {
26284
26161
  namespace Content {
26285
26162
  interface ApplicationJson {
26286
26163
  [k: string]: unknown;
26287
26164
  }
26288
26165
  }
26289
26166
  }
26290
- }
26291
- }
26292
- }
26293
- namespace ExperimentalV2CustomersCustomerIdUnlockedLeadsExports { }
26294
- namespace V2ExperimentalCustomersCustomerIdUnlockedLeadsExports { }
26295
- namespace V2CustomersCustomerIdUnlockedLeadsExports {
26296
- namespace Get {
26297
- namespace Parameters {
26298
- type Path = {
26299
- customerId: string;
26300
- };
26301
- type Header = {};
26302
- type Query = {
26303
- limit?: number;
26304
- skip?: number;
26305
- page?: number;
26306
- sort?: "exportedAt";
26307
- order?: "asc" | "desc";
26308
- };
26309
- }
26310
- namespace Responses {
26311
- namespace $200 {
26312
- namespace Content {
26313
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LeadfyndrLeadsExport[];
26314
- }
26315
- }
26316
- namespace $400 {
26167
+ namespace $404 {
26317
26168
  namespace Content {
26318
26169
  interface ApplicationJson {
26319
26170
  [k: string]: unknown;
26320
26171
  }
26321
26172
  }
26322
26173
  }
26323
- namespace $403 {
26174
+ namespace $429 {
26324
26175
  namespace Content {
26325
26176
  interface ApplicationJson {
26326
26177
  [k: string]: unknown;
26327
26178
  }
26328
26179
  }
26329
26180
  }
26330
- namespace $404 {
26181
+ namespace $500 {
26331
26182
  namespace Content {
26332
26183
  interface ApplicationJson {
26333
26184
  [k: string]: unknown;
26334
26185
  }
26335
26186
  }
26336
26187
  }
26337
- namespace $429 {
26188
+ namespace $503 {
26338
26189
  namespace Content {
26339
26190
  interface ApplicationJson {
26340
26191
  [k: string]: unknown;
@@ -26351,22 +26202,20 @@ export declare namespace MittwaldAPIV2 {
26351
26202
  }
26352
26203
  }
26353
26204
  }
26354
- namespace ExperimentalV2CustomersCustomerIdUnlockedLeadsLeadId { }
26355
- namespace V2ExperimentalCustomersCustomerIdUnlockedLeadsLeadId { }
26356
- namespace V2CustomersCustomerIdUnlockedLeadsLeadId {
26205
+ namespace V2DeliveryboxesDeliveryBoxId { }
26206
+ namespace V2DeliveryBoxesDeliveryBoxId {
26357
26207
  namespace Get {
26358
26208
  namespace Parameters {
26359
26209
  type Path = {
26360
- leadId: string;
26361
- customerId: string;
26210
+ deliveryBoxId: string;
26362
26211
  };
26363
- type Header = {};
26212
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26364
26213
  type Query = {};
26365
26214
  }
26366
26215
  namespace Responses {
26367
26216
  namespace $200 {
26368
26217
  namespace Content {
26369
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LeadfyndrUnlockedLead;
26218
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailDeliverybox;
26370
26219
  }
26371
26220
  }
26372
26221
  namespace $400 {
@@ -26397,6 +26246,20 @@ export declare namespace MittwaldAPIV2 {
26397
26246
  }
26398
26247
  }
26399
26248
  }
26249
+ namespace $500 {
26250
+ namespace Content {
26251
+ interface ApplicationJson {
26252
+ [k: string]: unknown;
26253
+ }
26254
+ }
26255
+ }
26256
+ namespace $503 {
26257
+ namespace Content {
26258
+ interface ApplicationJson {
26259
+ [k: string]: unknown;
26260
+ }
26261
+ }
26262
+ }
26400
26263
  namespace Default {
26401
26264
  namespace Content {
26402
26265
  interface ApplicationJson {
@@ -26406,21 +26269,18 @@ export declare namespace MittwaldAPIV2 {
26406
26269
  }
26407
26270
  }
26408
26271
  }
26409
- namespace Post {
26272
+ namespace Delete {
26410
26273
  namespace Parameters {
26411
26274
  type Path = {
26412
- leadId: string;
26413
- customerId: string;
26275
+ deliveryBoxId: string;
26414
26276
  };
26415
- type Header = {};
26277
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26416
26278
  type Query = {};
26417
26279
  }
26418
26280
  namespace Responses {
26419
- namespace $200 {
26281
+ namespace $204 {
26420
26282
  namespace Content {
26421
- interface ApplicationJson {
26422
- leadId: string;
26423
- }
26283
+ type Empty = unknown;
26424
26284
  }
26425
26285
  }
26426
26286
  namespace $400 {
@@ -26451,72 +26311,14 @@ export declare namespace MittwaldAPIV2 {
26451
26311
  }
26452
26312
  }
26453
26313
  }
26454
- namespace Default {
26455
- namespace Content {
26456
- interface ApplicationJson {
26457
- [k: string]: unknown;
26458
- }
26459
- }
26460
- }
26461
- }
26462
- }
26463
- }
26464
- namespace ExperimentalV2CustomersCustomerIdLeads { }
26465
- namespace V2ExperimentalCustomersCustomerIdLeads { }
26466
- namespace V2CustomersCustomerIdLeads {
26467
- namespace Get {
26468
- namespace Parameters {
26469
- type Path = {
26470
- customerId: string;
26471
- };
26472
- type Header = {};
26473
- type Query = {
26474
- potentialRangeMin?: number;
26475
- potentialRangeMax?: number;
26476
- employeeCountMin?: number;
26477
- employeeCountMax?: number;
26478
- salesVolumeMin?: number;
26479
- salesVolumeMax?: number;
26480
- technologies?: (string | "none")[];
26481
- /**
26482
- * @maxItems 15
26483
- */
26484
- businessFields?: string[];
26485
- locationCity?: string;
26486
- locationPostCode?: string;
26487
- locationRadiusInKm?: number;
26488
- "basic:timeToFirstByteMs:min"?: number;
26489
- "basic:timeToFirstByteMs:max"?: number;
26490
- "basic:desktop:performance:min"?: number;
26491
- "basic:desktop:performance:max"?: number;
26492
- "basic:mobile:performance:min"?: number;
26493
- "basic:mobile:performance:max"?: number;
26494
- limit?: number;
26495
- skip?: number;
26496
- page?: number;
26497
- sort?: "potential" | "relevance";
26498
- order?: "asc" | "desc";
26499
- };
26500
- }
26501
- namespace Responses {
26502
- namespace $200 {
26503
- namespace Content {
26504
- interface ApplicationJson {
26505
- leads: MittwaldAPIV2.Components.Schemas.LeadfyndrLead[];
26506
- limit: number;
26507
- skip: number;
26508
- totalCount: number;
26509
- }
26510
- }
26511
- }
26512
- namespace $400 {
26314
+ namespace $500 {
26513
26315
  namespace Content {
26514
26316
  interface ApplicationJson {
26515
26317
  [k: string]: unknown;
26516
26318
  }
26517
26319
  }
26518
26320
  }
26519
- namespace $429 {
26321
+ namespace $503 {
26520
26322
  namespace Content {
26521
26323
  interface ApplicationJson {
26522
26324
  [k: string]: unknown;
@@ -26533,53 +26335,20 @@ export declare namespace MittwaldAPIV2 {
26533
26335
  }
26534
26336
  }
26535
26337
  }
26536
- namespace ExperimentalV2CustomersCustomerIdUnlockedLeads { }
26537
- namespace V2ExperimentalCustomersCustomerIdUnlockedLeads { }
26538
- namespace V2CustomersCustomerIdUnlockedLeads {
26338
+ namespace V2MailaddressesMailAddressId { }
26339
+ namespace V2MailAddressesMailAddressId {
26539
26340
  namespace Get {
26540
26341
  namespace Parameters {
26541
26342
  type Path = {
26542
- customerId: string;
26543
- };
26544
- type Header = {};
26545
- type Query = {
26546
- potentialRangeMin?: number;
26547
- potentialRangeMax?: number;
26548
- employeeCountMin?: number;
26549
- employeeCountMax?: number;
26550
- salesVolumeMin?: number;
26551
- salesVolumeMax?: number;
26552
- technologies?: (string | "none")[];
26553
- /**
26554
- * @maxItems 15
26555
- */
26556
- businessFields?: string[];
26557
- locationCity?: string;
26558
- locationPostCode?: string;
26559
- locationRadiusInKm?: number;
26560
- "basic:timeToFirstByteMs:min"?: number;
26561
- "basic:timeToFirstByteMs:max"?: number;
26562
- "basic:desktop:performance:min"?: number;
26563
- "basic:desktop:performance:max"?: number;
26564
- "basic:mobile:performance:min"?: number;
26565
- "basic:mobile:performance:max"?: number;
26566
- reserved?: boolean;
26567
- limit?: number;
26568
- skip?: number;
26569
- page?: number;
26570
- sort?: "potential" | "relevance" | "company";
26571
- order?: "asc" | "desc";
26343
+ mailAddressId: string;
26572
26344
  };
26345
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26346
+ type Query = {};
26573
26347
  }
26574
26348
  namespace Responses {
26575
26349
  namespace $200 {
26576
26350
  namespace Content {
26577
- interface ApplicationJson {
26578
- leads: MittwaldAPIV2.Components.Schemas.LeadfyndrUnlockedLead[];
26579
- limit: number;
26580
- skip: number;
26581
- totalCount: number;
26582
- }
26351
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailMailAddress;
26583
26352
  }
26584
26353
  }
26585
26354
  namespace $400 {
@@ -26610,6 +26379,20 @@ export declare namespace MittwaldAPIV2 {
26610
26379
  }
26611
26380
  }
26612
26381
  }
26382
+ namespace $500 {
26383
+ namespace Content {
26384
+ interface ApplicationJson {
26385
+ [k: string]: unknown;
26386
+ }
26387
+ }
26388
+ }
26389
+ namespace $503 {
26390
+ namespace Content {
26391
+ interface ApplicationJson {
26392
+ [k: string]: unknown;
26393
+ }
26394
+ }
26395
+ }
26613
26396
  namespace Default {
26614
26397
  namespace Content {
26615
26398
  interface ApplicationJson {
@@ -26619,25 +26402,18 @@ export declare namespace MittwaldAPIV2 {
26619
26402
  }
26620
26403
  }
26621
26404
  }
26622
- }
26623
- namespace ExperimentalV2CustomersCustomerIdUnlockedLeadsLeadIdReservation { }
26624
- namespace V2ExperimentalCustomersCustomerIdUnlockedLeadsLeadIdReservation { }
26625
- namespace V2CustomersCustomerIdUnlockedLeadsLeadIdReservation {
26626
- namespace Post {
26405
+ namespace Delete {
26627
26406
  namespace Parameters {
26628
26407
  type Path = {
26629
- leadId: string;
26630
- customerId: string;
26408
+ mailAddressId: string;
26631
26409
  };
26632
- type Header = {};
26410
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26633
26411
  type Query = {};
26634
26412
  }
26635
26413
  namespace Responses {
26636
- namespace $200 {
26414
+ namespace $204 {
26637
26415
  namespace Content {
26638
- interface ApplicationJson {
26639
- leadId: string;
26640
- }
26416
+ type Empty = unknown;
26641
26417
  }
26642
26418
  }
26643
26419
  namespace $400 {
@@ -26661,14 +26437,21 @@ export declare namespace MittwaldAPIV2 {
26661
26437
  }
26662
26438
  }
26663
26439
  }
26664
- namespace $409 {
26440
+ namespace $429 {
26665
26441
  namespace Content {
26666
26442
  interface ApplicationJson {
26667
26443
  [k: string]: unknown;
26668
26444
  }
26669
26445
  }
26670
26446
  }
26671
- namespace $429 {
26447
+ namespace $500 {
26448
+ namespace Content {
26449
+ interface ApplicationJson {
26450
+ [k: string]: unknown;
26451
+ }
26452
+ }
26453
+ }
26454
+ namespace $503 {
26672
26455
  namespace Content {
26673
26456
  interface ApplicationJson {
26674
26457
  [k: string]: unknown;
@@ -26684,21 +26467,20 @@ export declare namespace MittwaldAPIV2 {
26684
26467
  }
26685
26468
  }
26686
26469
  }
26470
+ }
26471
+ namespace V2MailAddressesMailAddressIdMailArchive {
26687
26472
  namespace Delete {
26688
26473
  namespace Parameters {
26689
26474
  type Path = {
26690
- leadId: string;
26691
- customerId: string;
26475
+ mailAddressId: string;
26692
26476
  };
26693
- type Header = {};
26477
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26694
26478
  type Query = {};
26695
26479
  }
26696
26480
  namespace Responses {
26697
- namespace $200 {
26481
+ namespace $204 {
26698
26482
  namespace Content {
26699
- interface ApplicationJson {
26700
- leadId: string;
26701
- }
26483
+ type Empty = unknown;
26702
26484
  }
26703
26485
  }
26704
26486
  namespace $400 {
@@ -26722,14 +26504,21 @@ export declare namespace MittwaldAPIV2 {
26722
26504
  }
26723
26505
  }
26724
26506
  }
26725
- namespace $409 {
26507
+ namespace $429 {
26726
26508
  namespace Content {
26727
26509
  interface ApplicationJson {
26728
26510
  [k: string]: unknown;
26729
26511
  }
26730
26512
  }
26731
26513
  }
26732
- namespace $429 {
26514
+ namespace $500 {
26515
+ namespace Content {
26516
+ interface ApplicationJson {
26517
+ [k: string]: unknown;
26518
+ }
26519
+ }
26520
+ }
26521
+ namespace $503 {
26733
26522
  namespace Content {
26734
26523
  interface ApplicationJson {
26735
26524
  [k: string]: unknown;
@@ -26746,11 +26535,11 @@ export declare namespace MittwaldAPIV2 {
26746
26535
  }
26747
26536
  }
26748
26537
  }
26749
- namespace V2LicensesLicenseId {
26538
+ namespace V2MailRateLimitsMailRateLimitId {
26750
26539
  namespace Get {
26751
26540
  namespace Parameters {
26752
26541
  type Path = {
26753
- licenseId: string;
26542
+ mailRateLimitId: string;
26754
26543
  };
26755
26544
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26756
26545
  type Query = {};
@@ -26758,17 +26547,10 @@ export declare namespace MittwaldAPIV2 {
26758
26547
  namespace Responses {
26759
26548
  namespace $200 {
26760
26549
  namespace Content {
26761
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LicenseLicense;
26762
- }
26763
- }
26764
- namespace $400 {
26765
- namespace Content {
26766
- interface ApplicationJson {
26767
- [k: string]: unknown;
26768
- }
26550
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailsystemRateLimit;
26769
26551
  }
26770
26552
  }
26771
- namespace $403 {
26553
+ namespace $404 {
26772
26554
  namespace Content {
26773
26555
  interface ApplicationJson {
26774
26556
  [k: string]: unknown;
@@ -26782,13 +26564,6 @@ export declare namespace MittwaldAPIV2 {
26782
26564
  }
26783
26565
  }
26784
26566
  }
26785
- namespace $500 {
26786
- namespace Content {
26787
- interface ApplicationJson {
26788
- [k: string]: unknown;
26789
- }
26790
- }
26791
- }
26792
26567
  namespace Default {
26793
26568
  namespace Content {
26794
26569
  interface ApplicationJson {
@@ -26799,23 +26574,19 @@ export declare namespace MittwaldAPIV2 {
26799
26574
  }
26800
26575
  }
26801
26576
  }
26802
- namespace V2ProjectsProjectIdLicenses {
26577
+ namespace V2MailAddressesMailAddressIdBackups {
26803
26578
  namespace Get {
26804
26579
  namespace Parameters {
26805
26580
  type Path = {
26806
- projectId: string;
26581
+ mailAddressId: string;
26807
26582
  };
26808
26583
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26809
- type Query = {
26810
- limit?: number;
26811
- skip?: number;
26812
- page?: number;
26813
- };
26584
+ type Query = {};
26814
26585
  }
26815
26586
  namespace Responses {
26816
26587
  namespace $200 {
26817
26588
  namespace Content {
26818
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LicenseLicense[];
26589
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailMailAddressBackup[];
26819
26590
  }
26820
26591
  }
26821
26592
  namespace $400 {
@@ -26832,6 +26603,13 @@ export declare namespace MittwaldAPIV2 {
26832
26603
  }
26833
26604
  }
26834
26605
  }
26606
+ namespace $404 {
26607
+ namespace Content {
26608
+ interface ApplicationJson {
26609
+ [k: string]: unknown;
26610
+ }
26611
+ }
26612
+ }
26835
26613
  namespace $429 {
26836
26614
  namespace Content {
26837
26615
  interface ApplicationJson {
@@ -26856,25 +26634,29 @@ export declare namespace MittwaldAPIV2 {
26856
26634
  }
26857
26635
  }
26858
26636
  }
26859
- namespace V2LicensesLicenseIdActionsRotateKey {
26860
- namespace Post {
26637
+ namespace V2MailAddresses {
26638
+ namespace Get {
26861
26639
  namespace Parameters {
26862
- type Path = {
26863
- licenseId: string;
26864
- };
26865
- /**
26866
- * Optional reference to a file containing the new key if it was not procured via mittwald.
26867
- */
26868
- interface RequestBody {
26869
- externalKey?: string;
26870
- }
26640
+ type Path = {};
26871
26641
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26872
- type Query = {};
26642
+ type Query = {
26643
+ projectId?: string;
26644
+ search?: string;
26645
+ forwardAddress?: boolean;
26646
+ catchAll?: boolean;
26647
+ autoResponder?: boolean;
26648
+ mailArchive?: boolean;
26649
+ limit?: number;
26650
+ skip?: number;
26651
+ page?: number;
26652
+ sort?: ("address.domain" | "address.local" | "updatedAt" | "projectId" | "mailbox.quota" | "mailbox.name" | "mailbox.storageInBytes.current" | "mailbox.storageInBytes.limit")[];
26653
+ order?: ("asc" | "desc")[];
26654
+ };
26873
26655
  }
26874
26656
  namespace Responses {
26875
26657
  namespace $200 {
26876
26658
  namespace Content {
26877
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LicenseKeyResponse;
26659
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailMailAddress[];
26878
26660
  }
26879
26661
  }
26880
26662
  namespace $400 {
@@ -26898,13 +26680,6 @@ export declare namespace MittwaldAPIV2 {
26898
26680
  }
26899
26681
  }
26900
26682
  }
26901
- namespace $412 {
26902
- namespace Content {
26903
- interface ApplicationJson {
26904
- [k: string]: unknown;
26905
- }
26906
- }
26907
- }
26908
26683
  namespace $429 {
26909
26684
  namespace Content {
26910
26685
  interface ApplicationJson {
@@ -26919,76 +26694,7 @@ export declare namespace MittwaldAPIV2 {
26919
26694
  }
26920
26695
  }
26921
26696
  }
26922
- namespace Default {
26923
- namespace Content {
26924
- interface ApplicationJson {
26925
- [k: string]: unknown;
26926
- }
26927
- }
26928
- }
26929
- }
26930
- }
26931
- }
26932
- namespace V2ProjectsProjectIdActionsValidateLicenseKey {
26933
- namespace Post {
26934
- namespace Parameters {
26935
- type Path = {
26936
- projectId: string;
26937
- };
26938
- /**
26939
- * The License key to validate.
26940
- */
26941
- interface RequestBody {
26942
- key: string;
26943
- kind: MittwaldAPIV2.Components.Schemas.LicenseKind;
26944
- }
26945
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26946
- type Query = {};
26947
- }
26948
- namespace Responses {
26949
- namespace $200 {
26950
- namespace Content {
26951
- interface ApplicationJson {
26952
- valid: boolean;
26953
- }
26954
- }
26955
- }
26956
- namespace $400 {
26957
- namespace Content {
26958
- interface ApplicationJson {
26959
- [k: string]: unknown;
26960
- }
26961
- }
26962
- }
26963
- namespace $403 {
26964
- namespace Content {
26965
- interface ApplicationJson {
26966
- [k: string]: unknown;
26967
- }
26968
- }
26969
- }
26970
- namespace $404 {
26971
- namespace Content {
26972
- interface ApplicationJson {
26973
- [k: string]: unknown;
26974
- }
26975
- }
26976
- }
26977
- namespace $412 {
26978
- namespace Content {
26979
- interface ApplicationJson {
26980
- [k: string]: unknown;
26981
- }
26982
- }
26983
- }
26984
- namespace $429 {
26985
- namespace Content {
26986
- interface ApplicationJson {
26987
- [k: string]: unknown;
26988
- }
26989
- }
26990
- }
26991
- namespace $500 {
26697
+ namespace $503 {
26992
26698
  namespace Content {
26993
26699
  interface ApplicationJson {
26994
26700
  [k: string]: unknown;
@@ -27005,46 +26711,17 @@ export declare namespace MittwaldAPIV2 {
27005
26711
  }
27006
26712
  }
27007
26713
  }
27008
- namespace V2ProjectsProjectIdDeliveryboxes { }
27009
- namespace V2ProjectsProjectIdDeliveryBoxes {
26714
+ namespace V2MailRateLimits {
27010
26715
  namespace Get {
27011
26716
  namespace Parameters {
27012
- type Path = {
27013
- projectId: string;
27014
- };
26717
+ type Path = {};
27015
26718
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27016
- type Query = {
27017
- search?: string;
27018
- limit?: number;
27019
- skip?: number;
27020
- page?: number;
27021
- };
26719
+ type Query = {};
27022
26720
  }
27023
26721
  namespace Responses {
27024
26722
  namespace $200 {
27025
26723
  namespace Content {
27026
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailDeliverybox[];
27027
- }
27028
- }
27029
- namespace $400 {
27030
- namespace Content {
27031
- interface ApplicationJson {
27032
- [k: string]: unknown;
27033
- }
27034
- }
27035
- }
27036
- namespace $403 {
27037
- namespace Content {
27038
- interface ApplicationJson {
27039
- [k: string]: unknown;
27040
- }
27041
- }
27042
- }
27043
- namespace $404 {
27044
- namespace Content {
27045
- interface ApplicationJson {
27046
- [k: string]: unknown;
27047
- }
26724
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailsystemRateLimit[];
27048
26725
  }
27049
26726
  }
27050
26727
  namespace $429 {
@@ -27054,20 +26731,6 @@ export declare namespace MittwaldAPIV2 {
27054
26731
  }
27055
26732
  }
27056
26733
  }
27057
- namespace $500 {
27058
- namespace Content {
27059
- interface ApplicationJson {
27060
- [k: string]: unknown;
27061
- }
27062
- }
27063
- }
27064
- namespace $503 {
27065
- namespace Content {
27066
- interface ApplicationJson {
27067
- [k: string]: unknown;
27068
- }
27069
- }
27070
- }
27071
26734
  namespace Default {
27072
26735
  namespace Content {
27073
26736
  interface ApplicationJson {
@@ -27077,26 +26740,24 @@ export declare namespace MittwaldAPIV2 {
27077
26740
  }
27078
26741
  }
27079
26742
  }
27080
- namespace Post {
26743
+ }
26744
+ namespace V2ProjectsProjectIdMailsettings { }
26745
+ namespace V2ProjectsProjectIdMailSettings {
26746
+ namespace Get {
27081
26747
  namespace Parameters {
27082
26748
  type Path = {
27083
26749
  projectId: string;
27084
26750
  };
27085
- interface RequestBody {
27086
- description: string;
27087
- /**
27088
- * Password of the Deliverybox. Write-only: it is never returned by any route.
27089
- */
27090
- password: string;
27091
- }
27092
26751
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27093
26752
  type Query = {};
27094
26753
  }
27095
26754
  namespace Responses {
27096
- namespace $201 {
26755
+ namespace $200 {
27097
26756
  namespace Content {
27098
26757
  interface ApplicationJson {
27099
- id: string;
26758
+ blacklist: string[];
26759
+ projectId: string;
26760
+ whitelist: string[];
27100
26761
  }
27101
26762
  }
27102
26763
  }
@@ -27152,31 +26813,20 @@ export declare namespace MittwaldAPIV2 {
27152
26813
  }
27153
26814
  }
27154
26815
  }
27155
- namespace V2ProjectsProjectIdMailaddresses { }
27156
- namespace V2ProjectsProjectIdMailAddresses {
27157
- namespace Get {
26816
+ namespace V2MailAddressesMailAddressIdBackupsBackupIdRecovery {
26817
+ namespace Post {
27158
26818
  namespace Parameters {
27159
26819
  type Path = {
27160
- projectId: string;
26820
+ mailAddressId: string;
26821
+ backupId: string;
27161
26822
  };
27162
26823
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27163
- type Query = {
27164
- search?: string;
27165
- forwardAddress?: boolean;
27166
- catchAll?: boolean;
27167
- autoResponder?: boolean;
27168
- mailArchive?: boolean;
27169
- limit?: number;
27170
- skip?: number;
27171
- page?: number;
27172
- sort?: ("address.domain" | "address.local" | "updatedAt" | "projectId" | "mailbox.quota" | "mailbox.name" | "mailbox.storageInBytes.current" | "mailbox.storageInBytes.limit")[];
27173
- order?: ("asc" | "desc")[];
27174
- };
26824
+ type Query = {};
27175
26825
  }
27176
26826
  namespace Responses {
27177
- namespace $200 {
26827
+ namespace $204 {
27178
26828
  namespace Content {
27179
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailMailAddress[];
26829
+ type Empty = unknown;
27180
26830
  }
27181
26831
  }
27182
26832
  namespace $400 {
@@ -27186,13 +26836,6 @@ export declare namespace MittwaldAPIV2 {
27186
26836
  }
27187
26837
  }
27188
26838
  }
27189
- namespace $403 {
27190
- namespace Content {
27191
- interface ApplicationJson {
27192
- [k: string]: unknown;
27193
- }
27194
- }
27195
- }
27196
26839
  namespace $404 {
27197
26840
  namespace Content {
27198
26841
  interface ApplicationJson {
@@ -27207,20 +26850,6 @@ export declare namespace MittwaldAPIV2 {
27207
26850
  }
27208
26851
  }
27209
26852
  }
27210
- namespace $500 {
27211
- namespace Content {
27212
- interface ApplicationJson {
27213
- [k: string]: unknown;
27214
- }
27215
- }
27216
- }
27217
- namespace $503 {
27218
- namespace Content {
27219
- interface ApplicationJson {
27220
- [k: string]: unknown;
27221
- }
27222
- }
27223
- }
27224
26853
  namespace Default {
27225
26854
  namespace Content {
27226
26855
  interface ApplicationJson {
@@ -27230,21 +26859,23 @@ export declare namespace MittwaldAPIV2 {
27230
26859
  }
27231
26860
  }
27232
26861
  }
26862
+ }
26863
+ namespace V2MailAddressesMailAddressIdActionsRequestRateLimitChange {
27233
26864
  namespace Post {
27234
26865
  namespace Parameters {
27235
26866
  type Path = {
27236
- projectId: string;
26867
+ mailAddressId: string;
27237
26868
  };
27238
- type RequestBody = MittwaldAPIV2.Components.Schemas.MailCreateForwardAddress | MittwaldAPIV2.Components.Schemas.MailCreateMailAddress;
26869
+ interface RequestBody {
26870
+ rateLimitId: string;
26871
+ }
27239
26872
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27240
26873
  type Query = {};
27241
26874
  }
27242
26875
  namespace Responses {
27243
- namespace $201 {
26876
+ namespace $204 {
27244
26877
  namespace Content {
27245
- interface ApplicationJson {
27246
- id: string;
27247
- }
26878
+ type Empty = unknown;
27248
26879
  }
27249
26880
  }
27250
26881
  namespace $400 {
@@ -27299,20 +26930,22 @@ export declare namespace MittwaldAPIV2 {
27299
26930
  }
27300
26931
  }
27301
26932
  }
27302
- namespace V2DeliveryboxesDeliveryBoxId { }
27303
- namespace V2DeliveryBoxesDeliveryBoxId {
27304
- namespace Get {
26933
+ namespace V2DeliveryBoxesDeliveryBoxIdDescription {
26934
+ namespace Patch {
27305
26935
  namespace Parameters {
27306
26936
  type Path = {
27307
26937
  deliveryBoxId: string;
27308
26938
  };
26939
+ interface RequestBody {
26940
+ description: string;
26941
+ }
27309
26942
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27310
26943
  type Query = {};
27311
26944
  }
27312
26945
  namespace Responses {
27313
- namespace $200 {
26946
+ namespace $204 {
27314
26947
  namespace Content {
27315
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailDeliverybox;
26948
+ type Empty = unknown;
27316
26949
  }
27317
26950
  }
27318
26951
  namespace $400 {
@@ -27366,11 +26999,16 @@ export declare namespace MittwaldAPIV2 {
27366
26999
  }
27367
27000
  }
27368
27001
  }
27369
- namespace Delete {
27002
+ }
27003
+ namespace V2DeliveryBoxesDeliveryBoxIdPassword {
27004
+ namespace Patch {
27370
27005
  namespace Parameters {
27371
27006
  type Path = {
27372
27007
  deliveryBoxId: string;
27373
27008
  };
27009
+ interface RequestBody {
27010
+ password: string;
27011
+ }
27374
27012
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27375
27013
  type Query = {};
27376
27014
  }
@@ -27432,20 +27070,22 @@ export declare namespace MittwaldAPIV2 {
27432
27070
  }
27433
27071
  }
27434
27072
  }
27435
- namespace V2MailaddressesMailAddressId { }
27436
- namespace V2MailAddressesMailAddressId {
27437
- namespace Get {
27073
+ namespace V2MailAddressesMailAddressIdAddress {
27074
+ namespace Patch {
27438
27075
  namespace Parameters {
27439
27076
  type Path = {
27440
27077
  mailAddressId: string;
27441
27078
  };
27079
+ interface RequestBody {
27080
+ address: string;
27081
+ }
27442
27082
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27443
27083
  type Query = {};
27444
27084
  }
27445
27085
  namespace Responses {
27446
- namespace $200 {
27086
+ namespace $204 {
27447
27087
  namespace Content {
27448
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailMailAddress;
27088
+ type Empty = unknown;
27449
27089
  }
27450
27090
  }
27451
27091
  namespace $400 {
@@ -27499,753 +27139,16 @@ export declare namespace MittwaldAPIV2 {
27499
27139
  }
27500
27140
  }
27501
27141
  }
27502
- namespace Delete {
27142
+ }
27143
+ namespace V2MailAddressesMailAddressIdCatchAll {
27144
+ namespace Patch {
27503
27145
  namespace Parameters {
27504
27146
  type Path = {
27505
27147
  mailAddressId: string;
27506
27148
  };
27507
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27508
- type Query = {};
27509
- }
27510
- namespace Responses {
27511
- namespace $204 {
27512
- namespace Content {
27513
- type Empty = unknown;
27514
- }
27515
- }
27516
- namespace $400 {
27517
- namespace Content {
27518
- interface ApplicationJson {
27519
- [k: string]: unknown;
27520
- }
27521
- }
27522
- }
27523
- namespace $403 {
27524
- namespace Content {
27525
- interface ApplicationJson {
27526
- [k: string]: unknown;
27527
- }
27528
- }
27529
- }
27530
- namespace $404 {
27531
- namespace Content {
27532
- interface ApplicationJson {
27533
- [k: string]: unknown;
27534
- }
27535
- }
27536
- }
27537
- namespace $429 {
27538
- namespace Content {
27539
- interface ApplicationJson {
27540
- [k: string]: unknown;
27541
- }
27542
- }
27543
- }
27544
- namespace $500 {
27545
- namespace Content {
27546
- interface ApplicationJson {
27547
- [k: string]: unknown;
27548
- }
27549
- }
27550
- }
27551
- namespace $503 {
27552
- namespace Content {
27553
- interface ApplicationJson {
27554
- [k: string]: unknown;
27555
- }
27556
- }
27557
- }
27558
- namespace Default {
27559
- namespace Content {
27560
- interface ApplicationJson {
27561
- [k: string]: unknown;
27562
- }
27563
- }
27564
- }
27565
- }
27566
- }
27567
- }
27568
- namespace V2MailAddressesMailAddressIdMailArchive {
27569
- namespace Delete {
27570
- namespace Parameters {
27571
- type Path = {
27572
- mailAddressId: string;
27573
- };
27574
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27575
- type Query = {};
27576
- }
27577
- namespace Responses {
27578
- namespace $204 {
27579
- namespace Content {
27580
- type Empty = unknown;
27581
- }
27582
- }
27583
- namespace $400 {
27584
- namespace Content {
27585
- interface ApplicationJson {
27586
- [k: string]: unknown;
27587
- }
27588
- }
27589
- }
27590
- namespace $403 {
27591
- namespace Content {
27592
- interface ApplicationJson {
27593
- [k: string]: unknown;
27594
- }
27595
- }
27596
- }
27597
- namespace $404 {
27598
- namespace Content {
27599
- interface ApplicationJson {
27600
- [k: string]: unknown;
27601
- }
27602
- }
27603
- }
27604
- namespace $429 {
27605
- namespace Content {
27606
- interface ApplicationJson {
27607
- [k: string]: unknown;
27608
- }
27609
- }
27610
- }
27611
- namespace $500 {
27612
- namespace Content {
27613
- interface ApplicationJson {
27614
- [k: string]: unknown;
27615
- }
27616
- }
27617
- }
27618
- namespace $503 {
27619
- namespace Content {
27620
- interface ApplicationJson {
27621
- [k: string]: unknown;
27622
- }
27623
- }
27624
- }
27625
- namespace Default {
27626
- namespace Content {
27627
- interface ApplicationJson {
27628
- [k: string]: unknown;
27629
- }
27630
- }
27631
- }
27632
- }
27633
- }
27634
- }
27635
- namespace V2MailRateLimitsMailRateLimitId {
27636
- namespace Get {
27637
- namespace Parameters {
27638
- type Path = {
27639
- mailRateLimitId: string;
27640
- };
27641
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27642
- type Query = {};
27643
- }
27644
- namespace Responses {
27645
- namespace $200 {
27646
- namespace Content {
27647
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailsystemRateLimit;
27648
- }
27649
- }
27650
- namespace $404 {
27651
- namespace Content {
27652
- interface ApplicationJson {
27653
- [k: string]: unknown;
27654
- }
27655
- }
27656
- }
27657
- namespace $429 {
27658
- namespace Content {
27659
- interface ApplicationJson {
27660
- [k: string]: unknown;
27661
- }
27662
- }
27663
- }
27664
- namespace Default {
27665
- namespace Content {
27666
- interface ApplicationJson {
27667
- [k: string]: unknown;
27668
- }
27669
- }
27670
- }
27671
- }
27672
- }
27673
- }
27674
- namespace V2MailAddressesMailAddressIdBackups {
27675
- namespace Get {
27676
- namespace Parameters {
27677
- type Path = {
27678
- mailAddressId: string;
27679
- };
27680
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27681
- type Query = {};
27682
- }
27683
- namespace Responses {
27684
- namespace $200 {
27685
- namespace Content {
27686
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailMailAddressBackup[];
27687
- }
27688
- }
27689
- namespace $400 {
27690
- namespace Content {
27691
- interface ApplicationJson {
27692
- [k: string]: unknown;
27693
- }
27694
- }
27695
- }
27696
- namespace $403 {
27697
- namespace Content {
27698
- interface ApplicationJson {
27699
- [k: string]: unknown;
27700
- }
27701
- }
27702
- }
27703
- namespace $404 {
27704
- namespace Content {
27705
- interface ApplicationJson {
27706
- [k: string]: unknown;
27707
- }
27708
- }
27709
- }
27710
- namespace $429 {
27711
- namespace Content {
27712
- interface ApplicationJson {
27713
- [k: string]: unknown;
27714
- }
27715
- }
27716
- }
27717
- namespace $500 {
27718
- namespace Content {
27719
- interface ApplicationJson {
27720
- [k: string]: unknown;
27721
- }
27722
- }
27723
- }
27724
- namespace Default {
27725
- namespace Content {
27726
- interface ApplicationJson {
27727
- [k: string]: unknown;
27728
- }
27729
- }
27730
- }
27731
- }
27732
- }
27733
- }
27734
- namespace V2MailAddresses {
27735
- namespace Get {
27736
- namespace Parameters {
27737
- type Path = {};
27738
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27739
- type Query = {
27740
- projectId?: string;
27741
- search?: string;
27742
- forwardAddress?: boolean;
27743
- catchAll?: boolean;
27744
- autoResponder?: boolean;
27745
- mailArchive?: boolean;
27746
- limit?: number;
27747
- skip?: number;
27748
- page?: number;
27749
- sort?: ("address.domain" | "address.local" | "updatedAt" | "projectId" | "mailbox.quota" | "mailbox.name" | "mailbox.storageInBytes.current" | "mailbox.storageInBytes.limit")[];
27750
- order?: ("asc" | "desc")[];
27751
- };
27752
- }
27753
- namespace Responses {
27754
- namespace $200 {
27755
- namespace Content {
27756
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailMailAddress[];
27757
- }
27758
- }
27759
- namespace $400 {
27760
- namespace Content {
27761
- interface ApplicationJson {
27762
- [k: string]: unknown;
27763
- }
27764
- }
27765
- }
27766
- namespace $403 {
27767
- namespace Content {
27768
- interface ApplicationJson {
27769
- [k: string]: unknown;
27770
- }
27771
- }
27772
- }
27773
- namespace $404 {
27774
- namespace Content {
27775
- interface ApplicationJson {
27776
- [k: string]: unknown;
27777
- }
27778
- }
27779
- }
27780
- namespace $429 {
27781
- namespace Content {
27782
- interface ApplicationJson {
27783
- [k: string]: unknown;
27784
- }
27785
- }
27786
- }
27787
- namespace $500 {
27788
- namespace Content {
27789
- interface ApplicationJson {
27790
- [k: string]: unknown;
27791
- }
27792
- }
27793
- }
27794
- namespace $503 {
27795
- namespace Content {
27796
- interface ApplicationJson {
27797
- [k: string]: unknown;
27798
- }
27799
- }
27800
- }
27801
- namespace Default {
27802
- namespace Content {
27803
- interface ApplicationJson {
27804
- [k: string]: unknown;
27805
- }
27806
- }
27807
- }
27808
- }
27809
- }
27810
- }
27811
- namespace V2MailRateLimits {
27812
- namespace Get {
27813
- namespace Parameters {
27814
- type Path = {};
27815
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27816
- type Query = {};
27817
- }
27818
- namespace Responses {
27819
- namespace $200 {
27820
- namespace Content {
27821
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailsystemRateLimit[];
27822
- }
27823
- }
27824
- namespace $429 {
27825
- namespace Content {
27826
- interface ApplicationJson {
27827
- [k: string]: unknown;
27828
- }
27829
- }
27830
- }
27831
- namespace Default {
27832
- namespace Content {
27833
- interface ApplicationJson {
27834
- [k: string]: unknown;
27835
- }
27836
- }
27837
- }
27838
- }
27839
- }
27840
- }
27841
- namespace V2ProjectsProjectIdMailsettings { }
27842
- namespace V2ProjectsProjectIdMailSettings {
27843
- namespace Get {
27844
- namespace Parameters {
27845
- type Path = {
27846
- projectId: string;
27847
- };
27848
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27849
- type Query = {};
27850
- }
27851
- namespace Responses {
27852
- namespace $200 {
27853
- namespace Content {
27854
- interface ApplicationJson {
27855
- blacklist: string[];
27856
- projectId: string;
27857
- whitelist: string[];
27858
- }
27859
- }
27860
- }
27861
- namespace $400 {
27862
- namespace Content {
27863
- interface ApplicationJson {
27864
- [k: string]: unknown;
27865
- }
27866
- }
27867
- }
27868
- namespace $403 {
27869
- namespace Content {
27870
- interface ApplicationJson {
27871
- [k: string]: unknown;
27872
- }
27873
- }
27874
- }
27875
- namespace $404 {
27876
- namespace Content {
27877
- interface ApplicationJson {
27878
- [k: string]: unknown;
27879
- }
27880
- }
27881
- }
27882
- namespace $429 {
27883
- namespace Content {
27884
- interface ApplicationJson {
27885
- [k: string]: unknown;
27886
- }
27887
- }
27888
- }
27889
- namespace $500 {
27890
- namespace Content {
27891
- interface ApplicationJson {
27892
- [k: string]: unknown;
27893
- }
27894
- }
27895
- }
27896
- namespace $503 {
27897
- namespace Content {
27898
- interface ApplicationJson {
27899
- [k: string]: unknown;
27900
- }
27901
- }
27902
- }
27903
- namespace Default {
27904
- namespace Content {
27905
- interface ApplicationJson {
27906
- [k: string]: unknown;
27907
- }
27908
- }
27909
- }
27910
- }
27911
- }
27912
- }
27913
- namespace V2MailAddressesMailAddressIdBackupsBackupIdRecovery {
27914
- namespace Post {
27915
- namespace Parameters {
27916
- type Path = {
27917
- mailAddressId: string;
27918
- backupId: string;
27919
- };
27920
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27921
- type Query = {};
27922
- }
27923
- namespace Responses {
27924
- namespace $204 {
27925
- namespace Content {
27926
- type Empty = unknown;
27927
- }
27928
- }
27929
- namespace $400 {
27930
- namespace Content {
27931
- interface ApplicationJson {
27932
- [k: string]: unknown;
27933
- }
27934
- }
27935
- }
27936
- namespace $404 {
27937
- namespace Content {
27938
- interface ApplicationJson {
27939
- [k: string]: unknown;
27940
- }
27941
- }
27942
- }
27943
- namespace $429 {
27944
- namespace Content {
27945
- interface ApplicationJson {
27946
- [k: string]: unknown;
27947
- }
27948
- }
27949
- }
27950
- namespace Default {
27951
- namespace Content {
27952
- interface ApplicationJson {
27953
- [k: string]: unknown;
27954
- }
27955
- }
27956
- }
27957
- }
27958
- }
27959
- }
27960
- namespace V2MailAddressesMailAddressIdActionsRequestRateLimitChange {
27961
- namespace Post {
27962
- namespace Parameters {
27963
- type Path = {
27964
- mailAddressId: string;
27965
- };
27966
- interface RequestBody {
27967
- rateLimitId: string;
27968
- }
27969
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27970
- type Query = {};
27971
- }
27972
- namespace Responses {
27973
- namespace $204 {
27974
- namespace Content {
27975
- type Empty = unknown;
27976
- }
27977
- }
27978
- namespace $400 {
27979
- namespace Content {
27980
- interface ApplicationJson {
27981
- [k: string]: unknown;
27982
- }
27983
- }
27984
- }
27985
- namespace $403 {
27986
- namespace Content {
27987
- interface ApplicationJson {
27988
- [k: string]: unknown;
27989
- }
27990
- }
27991
- }
27992
- namespace $404 {
27993
- namespace Content {
27994
- interface ApplicationJson {
27995
- [k: string]: unknown;
27996
- }
27997
- }
27998
- }
27999
- namespace $429 {
28000
- namespace Content {
28001
- interface ApplicationJson {
28002
- [k: string]: unknown;
28003
- }
28004
- }
28005
- }
28006
- namespace $500 {
28007
- namespace Content {
28008
- interface ApplicationJson {
28009
- [k: string]: unknown;
28010
- }
28011
- }
28012
- }
28013
- namespace $503 {
28014
- namespace Content {
28015
- interface ApplicationJson {
28016
- [k: string]: unknown;
28017
- }
28018
- }
28019
- }
28020
- namespace Default {
28021
- namespace Content {
28022
- interface ApplicationJson {
28023
- [k: string]: unknown;
28024
- }
28025
- }
28026
- }
28027
- }
28028
- }
28029
- }
28030
- namespace V2DeliveryBoxesDeliveryBoxIdDescription {
28031
- namespace Patch {
28032
- namespace Parameters {
28033
- type Path = {
28034
- deliveryBoxId: string;
28035
- };
28036
- interface RequestBody {
28037
- description: string;
28038
- }
28039
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
28040
- type Query = {};
28041
- }
28042
- namespace Responses {
28043
- namespace $204 {
28044
- namespace Content {
28045
- type Empty = unknown;
28046
- }
28047
- }
28048
- namespace $400 {
28049
- namespace Content {
28050
- interface ApplicationJson {
28051
- [k: string]: unknown;
28052
- }
28053
- }
28054
- }
28055
- namespace $403 {
28056
- namespace Content {
28057
- interface ApplicationJson {
28058
- [k: string]: unknown;
28059
- }
28060
- }
28061
- }
28062
- namespace $404 {
28063
- namespace Content {
28064
- interface ApplicationJson {
28065
- [k: string]: unknown;
28066
- }
28067
- }
28068
- }
28069
- namespace $429 {
28070
- namespace Content {
28071
- interface ApplicationJson {
28072
- [k: string]: unknown;
28073
- }
28074
- }
28075
- }
28076
- namespace $500 {
28077
- namespace Content {
28078
- interface ApplicationJson {
28079
- [k: string]: unknown;
28080
- }
28081
- }
28082
- }
28083
- namespace $503 {
28084
- namespace Content {
28085
- interface ApplicationJson {
28086
- [k: string]: unknown;
28087
- }
28088
- }
28089
- }
28090
- namespace Default {
28091
- namespace Content {
28092
- interface ApplicationJson {
28093
- [k: string]: unknown;
28094
- }
28095
- }
28096
- }
28097
- }
28098
- }
28099
- }
28100
- namespace V2DeliveryBoxesDeliveryBoxIdPassword {
28101
- namespace Patch {
28102
- namespace Parameters {
28103
- type Path = {
28104
- deliveryBoxId: string;
28105
- };
28106
- interface RequestBody {
28107
- password: string;
28108
- }
28109
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
28110
- type Query = {};
28111
- }
28112
- namespace Responses {
28113
- namespace $204 {
28114
- namespace Content {
28115
- type Empty = unknown;
28116
- }
28117
- }
28118
- namespace $400 {
28119
- namespace Content {
28120
- interface ApplicationJson {
28121
- [k: string]: unknown;
28122
- }
28123
- }
28124
- }
28125
- namespace $403 {
28126
- namespace Content {
28127
- interface ApplicationJson {
28128
- [k: string]: unknown;
28129
- }
28130
- }
28131
- }
28132
- namespace $404 {
28133
- namespace Content {
28134
- interface ApplicationJson {
28135
- [k: string]: unknown;
28136
- }
28137
- }
28138
- }
28139
- namespace $429 {
28140
- namespace Content {
28141
- interface ApplicationJson {
28142
- [k: string]: unknown;
28143
- }
28144
- }
28145
- }
28146
- namespace $500 {
28147
- namespace Content {
28148
- interface ApplicationJson {
28149
- [k: string]: unknown;
28150
- }
28151
- }
28152
- }
28153
- namespace $503 {
28154
- namespace Content {
28155
- interface ApplicationJson {
28156
- [k: string]: unknown;
28157
- }
28158
- }
28159
- }
28160
- namespace Default {
28161
- namespace Content {
28162
- interface ApplicationJson {
28163
- [k: string]: unknown;
28164
- }
28165
- }
28166
- }
28167
- }
28168
- }
28169
- }
28170
- namespace V2MailAddressesMailAddressIdAddress {
28171
- namespace Patch {
28172
- namespace Parameters {
28173
- type Path = {
28174
- mailAddressId: string;
28175
- };
28176
- interface RequestBody {
28177
- address: string;
28178
- }
28179
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
28180
- type Query = {};
28181
- }
28182
- namespace Responses {
28183
- namespace $204 {
28184
- namespace Content {
28185
- type Empty = unknown;
28186
- }
28187
- }
28188
- namespace $400 {
28189
- namespace Content {
28190
- interface ApplicationJson {
28191
- [k: string]: unknown;
28192
- }
28193
- }
28194
- }
28195
- namespace $403 {
28196
- namespace Content {
28197
- interface ApplicationJson {
28198
- [k: string]: unknown;
28199
- }
28200
- }
28201
- }
28202
- namespace $404 {
28203
- namespace Content {
28204
- interface ApplicationJson {
28205
- [k: string]: unknown;
28206
- }
28207
- }
28208
- }
28209
- namespace $429 {
28210
- namespace Content {
28211
- interface ApplicationJson {
28212
- [k: string]: unknown;
28213
- }
28214
- }
28215
- }
28216
- namespace $500 {
28217
- namespace Content {
28218
- interface ApplicationJson {
28219
- [k: string]: unknown;
28220
- }
28221
- }
28222
- }
28223
- namespace $503 {
28224
- namespace Content {
28225
- interface ApplicationJson {
28226
- [k: string]: unknown;
28227
- }
28228
- }
28229
- }
28230
- namespace Default {
28231
- namespace Content {
28232
- interface ApplicationJson {
28233
- [k: string]: unknown;
28234
- }
28235
- }
28236
- }
28237
- }
28238
- }
28239
- }
28240
- namespace V2MailAddressesMailAddressIdCatchAll {
28241
- namespace Patch {
28242
- namespace Parameters {
28243
- type Path = {
28244
- mailAddressId: string;
28245
- };
28246
- interface RequestBody {
28247
- active: boolean;
28248
- }
27149
+ interface RequestBody {
27150
+ active: boolean;
27151
+ }
28249
27152
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
28250
27153
  type Query = {};
28251
27154
  }
@@ -30004,49 +28907,257 @@ export declare namespace MittwaldAPIV2 {
30004
28907
  }
30005
28908
  }
30006
28909
  }
30007
- namespace Delete {
28910
+ namespace Delete {
28911
+ namespace Parameters {
28912
+ type Path = {
28913
+ projectId: string;
28914
+ };
28915
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
28916
+ type Query = {};
28917
+ }
28918
+ namespace Responses {
28919
+ namespace $204 {
28920
+ namespace Content {
28921
+ type Empty = unknown;
28922
+ }
28923
+ }
28924
+ namespace $400 {
28925
+ namespace Content {
28926
+ interface ApplicationJson {
28927
+ [k: string]: unknown;
28928
+ }
28929
+ }
28930
+ }
28931
+ namespace $403 {
28932
+ namespace Content {
28933
+ interface ApplicationJson {
28934
+ [k: string]: unknown;
28935
+ }
28936
+ }
28937
+ }
28938
+ namespace $412 {
28939
+ namespace Content {
28940
+ interface ApplicationJson {
28941
+ [k: string]: unknown;
28942
+ }
28943
+ }
28944
+ }
28945
+ namespace $429 {
28946
+ namespace Content {
28947
+ interface ApplicationJson {
28948
+ [k: string]: unknown;
28949
+ }
28950
+ }
28951
+ }
28952
+ namespace $500 {
28953
+ namespace Content {
28954
+ interface ApplicationJson {
28955
+ [k: string]: unknown;
28956
+ }
28957
+ }
28958
+ }
28959
+ namespace Default {
28960
+ namespace Content {
28961
+ interface ApplicationJson {
28962
+ [k: string]: unknown;
28963
+ }
28964
+ }
28965
+ }
28966
+ }
28967
+ }
28968
+ namespace Patch {
28969
+ namespace Parameters {
28970
+ type Path = {
28971
+ projectId: string;
28972
+ };
28973
+ interface RequestBody {
28974
+ description?: string;
28975
+ }
28976
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
28977
+ type Query = {};
28978
+ }
28979
+ namespace Responses {
28980
+ namespace $204 {
28981
+ namespace Content {
28982
+ type Empty = unknown;
28983
+ }
28984
+ }
28985
+ namespace $400 {
28986
+ namespace Content {
28987
+ interface ApplicationJson {
28988
+ [k: string]: unknown;
28989
+ }
28990
+ }
28991
+ }
28992
+ namespace $403 {
28993
+ namespace Content {
28994
+ interface ApplicationJson {
28995
+ [k: string]: unknown;
28996
+ }
28997
+ }
28998
+ }
28999
+ namespace $429 {
29000
+ namespace Content {
29001
+ interface ApplicationJson {
29002
+ [k: string]: unknown;
29003
+ }
29004
+ }
29005
+ }
29006
+ namespace Default {
29007
+ namespace Content {
29008
+ interface ApplicationJson {
29009
+ [k: string]: unknown;
29010
+ }
29011
+ }
29012
+ }
29013
+ }
29014
+ }
29015
+ }
29016
+ namespace V2ServersServerIdAvatar {
29017
+ namespace Post {
29018
+ namespace Parameters {
29019
+ type Path = {
29020
+ serverId: string;
29021
+ };
29022
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
29023
+ type Query = {};
29024
+ }
29025
+ namespace Responses {
29026
+ namespace $200 {
29027
+ namespace Content {
29028
+ interface ApplicationJson {
29029
+ refId: string;
29030
+ rules: MittwaldAPIV2.Components.Schemas.ProjectAvatarRules;
29031
+ }
29032
+ }
29033
+ }
29034
+ namespace $400 {
29035
+ namespace Content {
29036
+ interface ApplicationJson {
29037
+ [k: string]: unknown;
29038
+ }
29039
+ }
29040
+ }
29041
+ namespace $403 {
29042
+ namespace Content {
29043
+ interface ApplicationJson {
29044
+ [k: string]: unknown;
29045
+ }
29046
+ }
29047
+ }
29048
+ namespace $429 {
29049
+ namespace Content {
29050
+ interface ApplicationJson {
29051
+ [k: string]: unknown;
29052
+ }
29053
+ }
29054
+ }
29055
+ namespace Default {
29056
+ namespace Content {
29057
+ interface ApplicationJson {
29058
+ [k: string]: unknown;
29059
+ }
29060
+ }
29061
+ }
29062
+ }
29063
+ }
29064
+ namespace Delete {
29065
+ namespace Parameters {
29066
+ type Path = {
29067
+ serverId: string;
29068
+ };
29069
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
29070
+ type Query = {};
29071
+ }
29072
+ namespace Responses {
29073
+ namespace $204 {
29074
+ namespace Content {
29075
+ type Empty = unknown;
29076
+ }
29077
+ }
29078
+ namespace $400 {
29079
+ namespace Content {
29080
+ interface ApplicationJson {
29081
+ [k: string]: unknown;
29082
+ }
29083
+ }
29084
+ }
29085
+ namespace $403 {
29086
+ namespace Content {
29087
+ interface ApplicationJson {
29088
+ [k: string]: unknown;
29089
+ }
29090
+ }
29091
+ }
29092
+ namespace $429 {
29093
+ namespace Content {
29094
+ interface ApplicationJson {
29095
+ [k: string]: unknown;
29096
+ }
29097
+ }
29098
+ }
29099
+ namespace Default {
29100
+ namespace Content {
29101
+ interface ApplicationJson {
29102
+ [k: string]: unknown;
29103
+ }
29104
+ }
29105
+ }
29106
+ }
29107
+ }
29108
+ }
29109
+ namespace V2ProjectsProjectIdFilesystemDirectories { }
29110
+ namespace V2ProjectsProjectIdFilesystemDirectories {
29111
+ namespace Get {
30008
29112
  namespace Parameters {
30009
29113
  type Path = {
30010
29114
  projectId: string;
30011
29115
  };
30012
29116
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30013
- type Query = {};
29117
+ type Query = {
29118
+ directory?: string;
29119
+ name?: string;
29120
+ max_depth?: number;
29121
+ type?: string[];
29122
+ executable?: boolean;
29123
+ hidden?: boolean;
29124
+ };
30014
29125
  }
30015
29126
  namespace Responses {
30016
- namespace $204 {
29127
+ namespace $200 {
30017
29128
  namespace Content {
30018
- type Empty = unknown;
29129
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.ProjectFilesystemDirectoryListing;
30019
29130
  }
30020
29131
  }
30021
- namespace $400 {
29132
+ namespace $403 {
30022
29133
  namespace Content {
30023
29134
  interface ApplicationJson {
30024
29135
  [k: string]: unknown;
30025
29136
  }
30026
29137
  }
30027
29138
  }
30028
- namespace $403 {
29139
+ namespace $404 {
30029
29140
  namespace Content {
30030
29141
  interface ApplicationJson {
30031
29142
  [k: string]: unknown;
30032
29143
  }
30033
29144
  }
30034
29145
  }
30035
- namespace $412 {
29146
+ namespace $429 {
30036
29147
  namespace Content {
30037
29148
  interface ApplicationJson {
30038
29149
  [k: string]: unknown;
30039
29150
  }
30040
29151
  }
30041
29152
  }
30042
- namespace $429 {
29153
+ namespace $502 {
30043
29154
  namespace Content {
30044
29155
  interface ApplicationJson {
30045
29156
  [k: string]: unknown;
30046
29157
  }
30047
29158
  }
30048
29159
  }
30049
- namespace $500 {
29160
+ namespace $503 {
30050
29161
  namespace Content {
30051
29162
  interface ApplicationJson {
30052
29163
  [k: string]: unknown;
@@ -30062,31 +29173,33 @@ export declare namespace MittwaldAPIV2 {
30062
29173
  }
30063
29174
  }
30064
29175
  }
30065
- namespace Patch {
29176
+ }
29177
+ namespace V2ProjectsProjectIdFilesystemUsagesDisk { }
29178
+ namespace V2ProjectsProjectIdFilesystemDiskUsage {
29179
+ namespace Get {
30066
29180
  namespace Parameters {
30067
29181
  type Path = {
30068
29182
  projectId: string;
30069
29183
  };
30070
- interface RequestBody {
30071
- description?: string;
30072
- }
30073
29184
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30074
- type Query = {};
29185
+ type Query = {
29186
+ directory?: string;
29187
+ };
30075
29188
  }
30076
29189
  namespace Responses {
30077
- namespace $204 {
29190
+ namespace $200 {
30078
29191
  namespace Content {
30079
- type Empty = unknown;
29192
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.ProjectFilesystemUsagesDisk;
30080
29193
  }
30081
29194
  }
30082
- namespace $400 {
29195
+ namespace $403 {
30083
29196
  namespace Content {
30084
29197
  interface ApplicationJson {
30085
29198
  [k: string]: unknown;
30086
29199
  }
30087
29200
  }
30088
29201
  }
30089
- namespace $403 {
29202
+ namespace $404 {
30090
29203
  namespace Content {
30091
29204
  interface ApplicationJson {
30092
29205
  [k: string]: unknown;
@@ -30100,6 +29213,20 @@ export declare namespace MittwaldAPIV2 {
30100
29213
  }
30101
29214
  }
30102
29215
  }
29216
+ namespace $502 {
29217
+ namespace Content {
29218
+ interface ApplicationJson {
29219
+ [k: string]: unknown;
29220
+ }
29221
+ }
29222
+ }
29223
+ namespace $503 {
29224
+ namespace Content {
29225
+ interface ApplicationJson {
29226
+ [k: string]: unknown;
29227
+ }
29228
+ }
29229
+ }
30103
29230
  namespace Default {
30104
29231
  namespace Content {
30105
29232
  interface ApplicationJson {
@@ -30110,29 +29237,31 @@ export declare namespace MittwaldAPIV2 {
30110
29237
  }
30111
29238
  }
30112
29239
  }
30113
- namespace V2ServersServerIdAvatar {
30114
- namespace Post {
29240
+ namespace V2ProjectsProjectIdFilesystemFilesRaw { }
29241
+ namespace V2ProjectsProjectIdFilesystemFileContent {
29242
+ namespace Get {
30115
29243
  namespace Parameters {
30116
29244
  type Path = {
30117
- serverId: string;
29245
+ projectId: string;
29246
+ };
29247
+ type Header = {
29248
+ Range?: string;
29249
+ "If-Range"?: string;
29250
+ } & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
29251
+ type Query = {
29252
+ file?: string;
29253
+ inline?: boolean;
30118
29254
  };
30119
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30120
- type Query = {};
30121
29255
  }
30122
29256
  namespace Responses {
30123
29257
  namespace $200 {
30124
29258
  namespace Content {
30125
- interface ApplicationJson {
30126
- refId: string;
30127
- rules: MittwaldAPIV2.Components.Schemas.ProjectAvatarRules;
30128
- }
29259
+ type ApplicationOctetStream = string;
30129
29260
  }
30130
29261
  }
30131
- namespace $400 {
29262
+ namespace $206 {
30132
29263
  namespace Content {
30133
- interface ApplicationJson {
30134
- [k: string]: unknown;
30135
- }
29264
+ type ApplicationOctetStream = string;
30136
29265
  }
30137
29266
  }
30138
29267
  namespace $403 {
@@ -30142,51 +29271,35 @@ export declare namespace MittwaldAPIV2 {
30142
29271
  }
30143
29272
  }
30144
29273
  }
30145
- namespace $429 {
29274
+ namespace $404 {
30146
29275
  namespace Content {
30147
29276
  interface ApplicationJson {
30148
29277
  [k: string]: unknown;
30149
29278
  }
30150
29279
  }
30151
29280
  }
30152
- namespace Default {
29281
+ namespace $416 {
30153
29282
  namespace Content {
30154
29283
  interface ApplicationJson {
30155
29284
  [k: string]: unknown;
30156
29285
  }
30157
29286
  }
30158
29287
  }
30159
- }
30160
- }
30161
- namespace Delete {
30162
- namespace Parameters {
30163
- type Path = {
30164
- serverId: string;
30165
- };
30166
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30167
- type Query = {};
30168
- }
30169
- namespace Responses {
30170
- namespace $204 {
30171
- namespace Content {
30172
- type Empty = unknown;
30173
- }
30174
- }
30175
- namespace $400 {
29288
+ namespace $429 {
30176
29289
  namespace Content {
30177
29290
  interface ApplicationJson {
30178
29291
  [k: string]: unknown;
30179
29292
  }
30180
29293
  }
30181
29294
  }
30182
- namespace $403 {
29295
+ namespace $502 {
30183
29296
  namespace Content {
30184
29297
  interface ApplicationJson {
30185
29298
  [k: string]: unknown;
30186
29299
  }
30187
29300
  }
30188
29301
  }
30189
- namespace $429 {
29302
+ namespace $503 {
30190
29303
  namespace Content {
30191
29304
  interface ApplicationJson {
30192
29305
  [k: string]: unknown;
@@ -30203,65 +29316,57 @@ export declare namespace MittwaldAPIV2 {
30203
29316
  }
30204
29317
  }
30205
29318
  }
30206
- namespace V2ProjectsProjectIdFilesystemDirectories { }
30207
- namespace V2ProjectsProjectIdFilesystemDirectories {
29319
+ namespace V2ProjectsProjectIdJwt {
30208
29320
  namespace Get {
30209
29321
  namespace Parameters {
30210
29322
  type Path = {
30211
29323
  projectId: string;
30212
29324
  };
30213
29325
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30214
- type Query = {
30215
- directory?: string;
30216
- name?: string;
30217
- max_depth?: number;
30218
- type?: string[];
30219
- executable?: boolean;
30220
- hidden?: boolean;
30221
- };
29326
+ type Query = {};
30222
29327
  }
30223
29328
  namespace Responses {
30224
29329
  namespace $200 {
30225
29330
  namespace Content {
30226
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.ProjectFilesystemDirectoryListing;
29331
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.ProjectFsApiJwt;
30227
29332
  }
30228
29333
  }
30229
- namespace $403 {
29334
+ namespace $401 {
30230
29335
  namespace Content {
30231
29336
  interface ApplicationJson {
30232
29337
  [k: string]: unknown;
30233
29338
  }
30234
29339
  }
30235
29340
  }
30236
- namespace $404 {
29341
+ namespace $403 {
30237
29342
  namespace Content {
30238
29343
  interface ApplicationJson {
30239
29344
  [k: string]: unknown;
30240
29345
  }
30241
29346
  }
30242
29347
  }
30243
- namespace $429 {
29348
+ namespace $404 {
30244
29349
  namespace Content {
30245
29350
  interface ApplicationJson {
30246
29351
  [k: string]: unknown;
30247
29352
  }
30248
29353
  }
30249
29354
  }
30250
- namespace $502 {
29355
+ namespace $429 {
30251
29356
  namespace Content {
30252
29357
  interface ApplicationJson {
30253
29358
  [k: string]: unknown;
30254
29359
  }
30255
29360
  }
30256
29361
  }
30257
- namespace $503 {
29362
+ namespace $502 {
30258
29363
  namespace Content {
30259
29364
  interface ApplicationJson {
30260
29365
  [k: string]: unknown;
30261
29366
  }
30262
29367
  }
30263
29368
  }
30264
- namespace Default {
29369
+ namespace $503 {
30265
29370
  namespace Content {
30266
29371
  interface ApplicationJson {
30267
29372
  [k: string]: unknown;
@@ -30271,8 +29376,8 @@ export declare namespace MittwaldAPIV2 {
30271
29376
  }
30272
29377
  }
30273
29378
  }
30274
- namespace V2ProjectsProjectIdFilesystemUsagesDisk { }
30275
- namespace V2ProjectsProjectIdFilesystemDiskUsage {
29379
+ namespace V2ProjectsProjectIdFilesystemFiles { }
29380
+ namespace V2ProjectsProjectIdFilesystemFiles {
30276
29381
  namespace Get {
30277
29382
  namespace Parameters {
30278
29383
  type Path = {
@@ -30280,13 +29385,13 @@ export declare namespace MittwaldAPIV2 {
30280
29385
  };
30281
29386
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30282
29387
  type Query = {
30283
- directory?: string;
29388
+ file?: string;
30284
29389
  };
30285
29390
  }
30286
29391
  namespace Responses {
30287
29392
  namespace $200 {
30288
29393
  namespace Content {
30289
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.ProjectFilesystemUsagesDisk;
29394
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.ProjectFilesystemDirectoryListing;
30290
29395
  }
30291
29396
  }
30292
29397
  namespace $403 {
@@ -30334,69 +29439,75 @@ export declare namespace MittwaldAPIV2 {
30334
29439
  }
30335
29440
  }
30336
29441
  }
30337
- namespace V2ProjectsProjectIdFilesystemFilesRaw { }
30338
- namespace V2ProjectsProjectIdFilesystemFileContent {
29442
+ namespace V2ProjectTokenInvite {
30339
29443
  namespace Get {
30340
29444
  namespace Parameters {
30341
- type Path = {
30342
- projectId: string;
30343
- };
29445
+ type Path = {};
30344
29446
  type Header = {
30345
- Range?: string;
30346
- "If-Range"?: string;
29447
+ token: string;
30347
29448
  } & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30348
- type Query = {
30349
- file?: string;
30350
- inline?: boolean;
30351
- };
29449
+ type Query = {};
30352
29450
  }
30353
29451
  namespace Responses {
30354
29452
  namespace $200 {
30355
29453
  namespace Content {
30356
- type ApplicationOctetStream = string;
30357
- }
30358
- }
30359
- namespace $206 {
30360
- namespace Content {
30361
- type ApplicationOctetStream = string;
29454
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MembershipProjectInvite;
30362
29455
  }
30363
29456
  }
30364
- namespace $403 {
29457
+ namespace $404 {
30365
29458
  namespace Content {
30366
29459
  interface ApplicationJson {
30367
29460
  [k: string]: unknown;
30368
29461
  }
30369
29462
  }
30370
29463
  }
30371
- namespace $404 {
29464
+ namespace $429 {
30372
29465
  namespace Content {
30373
29466
  interface ApplicationJson {
30374
29467
  [k: string]: unknown;
30375
29468
  }
30376
29469
  }
30377
29470
  }
30378
- namespace $416 {
29471
+ namespace Default {
30379
29472
  namespace Content {
30380
29473
  interface ApplicationJson {
30381
29474
  [k: string]: unknown;
30382
29475
  }
30383
29476
  }
30384
29477
  }
30385
- namespace $429 {
29478
+ }
29479
+ }
29480
+ }
29481
+ namespace V2ProjectsProjectIdMembershipsSelf {
29482
+ namespace Get {
29483
+ namespace Parameters {
29484
+ type Path = {
29485
+ projectId: string;
29486
+ };
29487
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
29488
+ type Query = {};
29489
+ }
29490
+ namespace Responses {
29491
+ namespace $200 {
29492
+ namespace Content {
29493
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MembershipProjectMembership;
29494
+ }
29495
+ }
29496
+ namespace $403 {
30386
29497
  namespace Content {
30387
29498
  interface ApplicationJson {
30388
29499
  [k: string]: unknown;
30389
29500
  }
30390
29501
  }
30391
29502
  }
30392
- namespace $502 {
29503
+ namespace $404 {
30393
29504
  namespace Content {
30394
29505
  interface ApplicationJson {
30395
29506
  [k: string]: unknown;
30396
29507
  }
30397
29508
  }
30398
29509
  }
30399
- namespace $503 {
29510
+ namespace $429 {
30400
29511
  namespace Content {
30401
29512
  interface ApplicationJson {
30402
29513
  [k: string]: unknown;
@@ -30413,22 +29524,26 @@ export declare namespace MittwaldAPIV2 {
30413
29524
  }
30414
29525
  }
30415
29526
  }
30416
- namespace V2ProjectsProjectIdJwt {
29527
+ namespace V2ServersServerIdUsageMetricsBreakdown {
30417
29528
  namespace Get {
30418
29529
  namespace Parameters {
30419
29530
  type Path = {
30420
- projectId: string;
29531
+ serverId: string;
30421
29532
  };
30422
29533
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30423
- type Query = {};
29534
+ type Query = {
29535
+ metric: "cpu" | "memory";
29536
+ from?: string | Date;
29537
+ to?: string | Date;
29538
+ };
30424
29539
  }
30425
29540
  namespace Responses {
30426
29541
  namespace $200 {
30427
29542
  namespace Content {
30428
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.ProjectFsApiJwt;
29543
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.UsagemetricsGetServerUsageBreakdownResponse;
30429
29544
  }
30430
29545
  }
30431
- namespace $401 {
29546
+ namespace $400 {
30432
29547
  namespace Content {
30433
29548
  interface ApplicationJson {
30434
29549
  [k: string]: unknown;
@@ -30449,6 +29564,13 @@ export declare namespace MittwaldAPIV2 {
30449
29564
  }
30450
29565
  }
30451
29566
  }
29567
+ namespace $412 {
29568
+ namespace Content {
29569
+ interface ApplicationJson {
29570
+ [k: string]: unknown;
29571
+ }
29572
+ }
29573
+ }
30452
29574
  namespace $429 {
30453
29575
  namespace Content {
30454
29576
  interface ApplicationJson {
@@ -30456,7 +29578,7 @@ export declare namespace MittwaldAPIV2 {
30456
29578
  }
30457
29579
  }
30458
29580
  }
30459
- namespace $502 {
29581
+ namespace $500 {
30460
29582
  namespace Content {
30461
29583
  interface ApplicationJson {
30462
29584
  [k: string]: unknown;
@@ -30470,25 +29592,40 @@ export declare namespace MittwaldAPIV2 {
30470
29592
  }
30471
29593
  }
30472
29594
  }
29595
+ namespace Default {
29596
+ namespace Content {
29597
+ interface ApplicationJson {
29598
+ [k: string]: unknown;
29599
+ }
29600
+ }
29601
+ }
30473
29602
  }
30474
29603
  }
30475
29604
  }
30476
- namespace V2ProjectsProjectIdFilesystemFiles { }
30477
- namespace V2ProjectsProjectIdFilesystemFiles {
29605
+ namespace V2ServersServerIdUsageMetrics {
30478
29606
  namespace Get {
30479
29607
  namespace Parameters {
30480
29608
  type Path = {
30481
- projectId: string;
29609
+ serverId: string;
30482
29610
  };
30483
29611
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30484
29612
  type Query = {
30485
- file?: string;
29613
+ metric: "cpu" | "memory";
29614
+ from?: string | Date;
29615
+ to?: string | Date;
30486
29616
  };
30487
29617
  }
30488
29618
  namespace Responses {
30489
29619
  namespace $200 {
30490
29620
  namespace Content {
30491
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.ProjectFilesystemDirectoryListing;
29621
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.UsagemetricsGetUsageResponse;
29622
+ }
29623
+ }
29624
+ namespace $400 {
29625
+ namespace Content {
29626
+ interface ApplicationJson {
29627
+ [k: string]: unknown;
29628
+ }
30492
29629
  }
30493
29630
  }
30494
29631
  namespace $403 {
@@ -30505,6 +29642,13 @@ export declare namespace MittwaldAPIV2 {
30505
29642
  }
30506
29643
  }
30507
29644
  }
29645
+ namespace $412 {
29646
+ namespace Content {
29647
+ interface ApplicationJson {
29648
+ [k: string]: unknown;
29649
+ }
29650
+ }
29651
+ }
30508
29652
  namespace $429 {
30509
29653
  namespace Content {
30510
29654
  interface ApplicationJson {
@@ -30512,7 +29656,7 @@ export declare namespace MittwaldAPIV2 {
30512
29656
  }
30513
29657
  }
30514
29658
  }
30515
- namespace $502 {
29659
+ namespace $500 {
30516
29660
  namespace Content {
30517
29661
  interface ApplicationJson {
30518
29662
  [k: string]: unknown;
@@ -30536,19 +29680,26 @@ export declare namespace MittwaldAPIV2 {
30536
29680
  }
30537
29681
  }
30538
29682
  }
30539
- namespace V2ProjectTokenInvite {
29683
+ namespace V2ServersServerId {
30540
29684
  namespace Get {
30541
29685
  namespace Parameters {
30542
- type Path = {};
30543
- type Header = {
30544
- token: string;
30545
- } & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
29686
+ type Path = {
29687
+ serverId: string;
29688
+ };
29689
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30546
29690
  type Query = {};
30547
29691
  }
30548
29692
  namespace Responses {
30549
29693
  namespace $200 {
30550
29694
  namespace Content {
30551
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.MembershipProjectInvite;
29695
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.ProjectServer;
29696
+ }
29697
+ }
29698
+ namespace $403 {
29699
+ namespace Content {
29700
+ interface ApplicationJson {
29701
+ [k: string]: unknown;
29702
+ }
30552
29703
  }
30553
29704
  }
30554
29705
  namespace $404 {
@@ -30574,30 +29725,31 @@ export declare namespace MittwaldAPIV2 {
30574
29725
  }
30575
29726
  }
30576
29727
  }
30577
- }
30578
- namespace V2ProjectsProjectIdMembershipsSelf {
30579
- namespace Get {
29728
+ namespace Patch {
30580
29729
  namespace Parameters {
30581
29730
  type Path = {
30582
- projectId: string;
29731
+ serverId: string;
30583
29732
  };
29733
+ interface RequestBody {
29734
+ description?: string;
29735
+ }
30584
29736
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30585
29737
  type Query = {};
30586
29738
  }
30587
29739
  namespace Responses {
30588
- namespace $200 {
29740
+ namespace $204 {
30589
29741
  namespace Content {
30590
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.MembershipProjectMembership;
29742
+ type Empty = unknown;
30591
29743
  }
30592
29744
  }
30593
- namespace $403 {
29745
+ namespace $400 {
30594
29746
  namespace Content {
30595
29747
  interface ApplicationJson {
30596
29748
  [k: string]: unknown;
30597
29749
  }
30598
29750
  }
30599
29751
  }
30600
- namespace $404 {
29752
+ namespace $403 {
30601
29753
  namespace Content {
30602
29754
  interface ApplicationJson {
30603
29755
  [k: string]: unknown;
@@ -30621,11 +29773,11 @@ export declare namespace MittwaldAPIV2 {
30621
29773
  }
30622
29774
  }
30623
29775
  }
30624
- namespace V2ServersServerIdUsageMetricsBreakdown {
29776
+ namespace V2ProjectsProjectIdUsageMetricsBreakdown {
30625
29777
  namespace Get {
30626
29778
  namespace Parameters {
30627
29779
  type Path = {
30628
- serverId: string;
29780
+ projectId: string;
30629
29781
  };
30630
29782
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30631
29783
  type Query = {
@@ -30637,7 +29789,7 @@ export declare namespace MittwaldAPIV2 {
30637
29789
  namespace Responses {
30638
29790
  namespace $200 {
30639
29791
  namespace Content {
30640
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.UsagemetricsGetServerUsageBreakdownResponse;
29792
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.UsagemetricsGetProjectUsageBreakdownResponse;
30641
29793
  }
30642
29794
  }
30643
29795
  namespace $400 {
@@ -30661,71 +29813,7 @@ export declare namespace MittwaldAPIV2 {
30661
29813
  }
30662
29814
  }
30663
29815
  }
30664
- namespace $429 {
30665
- namespace Content {
30666
- interface ApplicationJson {
30667
- [k: string]: unknown;
30668
- }
30669
- }
30670
- }
30671
- namespace $500 {
30672
- namespace Content {
30673
- interface ApplicationJson {
30674
- [k: string]: unknown;
30675
- }
30676
- }
30677
- }
30678
- namespace $503 {
30679
- namespace Content {
30680
- interface ApplicationJson {
30681
- [k: string]: unknown;
30682
- }
30683
- }
30684
- }
30685
- namespace Default {
30686
- namespace Content {
30687
- interface ApplicationJson {
30688
- [k: string]: unknown;
30689
- }
30690
- }
30691
- }
30692
- }
30693
- }
30694
- }
30695
- namespace V2ServersServerIdUsageMetrics {
30696
- namespace Get {
30697
- namespace Parameters {
30698
- type Path = {
30699
- serverId: string;
30700
- };
30701
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30702
- type Query = {
30703
- metric: "cpu" | "memory";
30704
- from?: string | Date;
30705
- to?: string | Date;
30706
- };
30707
- }
30708
- namespace Responses {
30709
- namespace $200 {
30710
- namespace Content {
30711
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.UsagemetricsGetUsageResponse;
30712
- }
30713
- }
30714
- namespace $400 {
30715
- namespace Content {
30716
- interface ApplicationJson {
30717
- [k: string]: unknown;
30718
- }
30719
- }
30720
- }
30721
- namespace $403 {
30722
- namespace Content {
30723
- interface ApplicationJson {
30724
- [k: string]: unknown;
30725
- }
30726
- }
30727
- }
30728
- namespace $404 {
29816
+ namespace $412 {
30729
29817
  namespace Content {
30730
29818
  interface ApplicationJson {
30731
29819
  [k: string]: unknown;
@@ -30763,100 +29851,7 @@ export declare namespace MittwaldAPIV2 {
30763
29851
  }
30764
29852
  }
30765
29853
  }
30766
- namespace V2ServersServerId {
30767
- namespace Get {
30768
- namespace Parameters {
30769
- type Path = {
30770
- serverId: string;
30771
- };
30772
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30773
- type Query = {};
30774
- }
30775
- namespace Responses {
30776
- namespace $200 {
30777
- namespace Content {
30778
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.ProjectServer;
30779
- }
30780
- }
30781
- namespace $403 {
30782
- namespace Content {
30783
- interface ApplicationJson {
30784
- [k: string]: unknown;
30785
- }
30786
- }
30787
- }
30788
- namespace $404 {
30789
- namespace Content {
30790
- interface ApplicationJson {
30791
- [k: string]: unknown;
30792
- }
30793
- }
30794
- }
30795
- namespace $429 {
30796
- namespace Content {
30797
- interface ApplicationJson {
30798
- [k: string]: unknown;
30799
- }
30800
- }
30801
- }
30802
- namespace Default {
30803
- namespace Content {
30804
- interface ApplicationJson {
30805
- [k: string]: unknown;
30806
- }
30807
- }
30808
- }
30809
- }
30810
- }
30811
- namespace Patch {
30812
- namespace Parameters {
30813
- type Path = {
30814
- serverId: string;
30815
- };
30816
- interface RequestBody {
30817
- description?: string;
30818
- }
30819
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30820
- type Query = {};
30821
- }
30822
- namespace Responses {
30823
- namespace $204 {
30824
- namespace Content {
30825
- type Empty = unknown;
30826
- }
30827
- }
30828
- namespace $400 {
30829
- namespace Content {
30830
- interface ApplicationJson {
30831
- [k: string]: unknown;
30832
- }
30833
- }
30834
- }
30835
- namespace $403 {
30836
- namespace Content {
30837
- interface ApplicationJson {
30838
- [k: string]: unknown;
30839
- }
30840
- }
30841
- }
30842
- namespace $429 {
30843
- namespace Content {
30844
- interface ApplicationJson {
30845
- [k: string]: unknown;
30846
- }
30847
- }
30848
- }
30849
- namespace Default {
30850
- namespace Content {
30851
- interface ApplicationJson {
30852
- [k: string]: unknown;
30853
- }
30854
- }
30855
- }
30856
- }
30857
- }
30858
- }
30859
- namespace V2ProjectsProjectIdUsageMetricsBreakdown {
29854
+ namespace V2ProjectsProjectIdUsageMetrics {
30860
29855
  namespace Get {
30861
29856
  namespace Parameters {
30862
29857
  type Path = {
@@ -30872,7 +29867,7 @@ export declare namespace MittwaldAPIV2 {
30872
29867
  namespace Responses {
30873
29868
  namespace $200 {
30874
29869
  namespace Content {
30875
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.UsagemetricsGetProjectUsageBreakdownResponse;
29870
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.UsagemetricsGetUsageResponse;
30876
29871
  }
30877
29872
  }
30878
29873
  namespace $400 {
@@ -30896,71 +29891,7 @@ export declare namespace MittwaldAPIV2 {
30896
29891
  }
30897
29892
  }
30898
29893
  }
30899
- namespace $429 {
30900
- namespace Content {
30901
- interface ApplicationJson {
30902
- [k: string]: unknown;
30903
- }
30904
- }
30905
- }
30906
- namespace $500 {
30907
- namespace Content {
30908
- interface ApplicationJson {
30909
- [k: string]: unknown;
30910
- }
30911
- }
30912
- }
30913
- namespace $503 {
30914
- namespace Content {
30915
- interface ApplicationJson {
30916
- [k: string]: unknown;
30917
- }
30918
- }
30919
- }
30920
- namespace Default {
30921
- namespace Content {
30922
- interface ApplicationJson {
30923
- [k: string]: unknown;
30924
- }
30925
- }
30926
- }
30927
- }
30928
- }
30929
- }
30930
- namespace V2ProjectsProjectIdUsageMetrics {
30931
- namespace Get {
30932
- namespace Parameters {
30933
- type Path = {
30934
- projectId: string;
30935
- };
30936
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
30937
- type Query = {
30938
- metric: "cpu" | "memory";
30939
- from?: string | Date;
30940
- to?: string | Date;
30941
- };
30942
- }
30943
- namespace Responses {
30944
- namespace $200 {
30945
- namespace Content {
30946
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.UsagemetricsGetUsageResponse;
30947
- }
30948
- }
30949
- namespace $400 {
30950
- namespace Content {
30951
- interface ApplicationJson {
30952
- [k: string]: unknown;
30953
- }
30954
- }
30955
- }
30956
- namespace $403 {
30957
- namespace Content {
30958
- interface ApplicationJson {
30959
- [k: string]: unknown;
30960
- }
30961
- }
30962
- }
30963
- namespace $404 {
29894
+ namespace $412 {
30964
29895
  namespace Content {
30965
29896
  interface ApplicationJson {
30966
29897
  [k: string]: unknown;
@@ -35835,5 +34766,68 @@ export declare namespace MittwaldAPIV2 {
35835
34766
  }
35836
34767
  }
35837
34768
  }
34769
+ namespace V2Authinfo2CheckDomain {
34770
+ namespace Post {
34771
+ namespace Parameters {
34772
+ type Path = {};
34773
+ interface RequestBody {
34774
+ domain: string;
34775
+ }
34776
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
34777
+ type Query = {};
34778
+ }
34779
+ namespace Responses {
34780
+ namespace $200 {
34781
+ namespace Content {
34782
+ interface ApplicationJson {
34783
+ eligible: boolean;
34784
+ reasons: {
34785
+ /**
34786
+ * The domain is already managed by mittwald; no AuthInfo2 is needed.
34787
+ */
34788
+ alreadyManaged: boolean;
34789
+ /**
34790
+ * The domain is not registered at DENIC.
34791
+ */
34792
+ notRegistered: boolean;
34793
+ /**
34794
+ * An AuthInfo2 was requested for this domain within the last 30 days.
34795
+ */
34796
+ recentlyTriggered: boolean;
34797
+ };
34798
+ }
34799
+ }
34800
+ }
34801
+ namespace $400 {
34802
+ namespace Content {
34803
+ interface ApplicationJson {
34804
+ [k: string]: unknown;
34805
+ }
34806
+ }
34807
+ }
34808
+ namespace $429 {
34809
+ namespace Content {
34810
+ interface ApplicationJson {
34811
+ [k: string]: unknown;
34812
+ }
34813
+ }
34814
+ }
34815
+ namespace $503 {
34816
+ namespace Content {
34817
+ interface ApplicationJson {
34818
+ [k: string]: unknown;
34819
+ }
34820
+ }
34821
+ }
34822
+ namespace Default {
34823
+ namespace Content {
34824
+ interface ApplicationJson {
34825
+ [k: string]: unknown;
34826
+ }
34827
+ }
34828
+ }
34829
+ }
34830
+ }
34831
+ }
35838
34832
  }
35839
34833
  }