@mittwald/api-client 4.523.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>;
@@ -1886,6 +1830,14 @@ export declare namespace MittwaldAPIV2 {
1886
1830
  type RequestData = InferredRequestData<typeof descriptors.userUpdatePersonalizedSettings>;
1887
1831
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userUpdatePersonalizedSettings, TStatus>;
1888
1832
  }
1833
+ namespace UserGetPollStatus {
1834
+ type RequestData = InferredRequestData<typeof descriptors.userGetPollStatus>;
1835
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userGetPollStatus, TStatus>;
1836
+ }
1837
+ namespace UserPostPollStatus {
1838
+ type RequestData = InferredRequestData<typeof descriptors.userPostPollStatus>;
1839
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userPostPollStatus, TStatus>;
1840
+ }
1889
1841
  namespace UserGetSession {
1890
1842
  type RequestData = InferredRequestData<typeof descriptors.userGetSession>;
1891
1843
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userGetSession, TStatus>;
@@ -1998,13 +1950,9 @@ export declare namespace MittwaldAPIV2 {
1998
1950
  type RequestData = InferredRequestData<typeof descriptors.verificationVerifyCompany>;
1999
1951
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.verificationVerifyCompany, TStatus>;
2000
1952
  }
2001
- namespace UserGetPollStatus {
2002
- type RequestData = InferredRequestData<typeof descriptors.userGetPollStatus>;
2003
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userGetPollStatus, TStatus>;
2004
- }
2005
- namespace UserPostPollStatus {
2006
- type RequestData = InferredRequestData<typeof descriptors.userPostPollStatus>;
2007
- type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userPostPollStatus, TStatus>;
1953
+ namespace DomainCheckAuthinfo2 {
1954
+ type RequestData = InferredRequestData<typeof descriptors.domainCheckAuthinfo2>;
1955
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.domainCheckAuthinfo2, TStatus>;
2008
1956
  }
2009
1957
  }
2010
1958
  namespace Components {
@@ -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
  }
@@ -9198,6 +8980,14 @@ export declare namespace MittwaldAPIV2 {
9198
8980
  key: string;
9199
8981
  sshKeyId: string;
9200
8982
  }
8983
+ interface PollUserPollSettings {
8984
+ completedAt?: string;
8985
+ dontShowUntil?: string;
8986
+ ignoredAt?: string;
8987
+ shouldShow: boolean;
8988
+ status: "completed" | "muted" | "ignored" | "new";
8989
+ userId: string;
8990
+ }
9201
8991
  interface SignupUserSession {
9202
8992
  created: string;
9203
8993
  device: MittwaldAPIV2.Components.Schemas.SignupDeviceInfo;
@@ -9274,14 +9064,6 @@ export declare namespace MittwaldAPIV2 {
9274
9064
  }
9275
9065
  type VerificationEmailOrigin = "IS_MITTWALD" | "IS_NOT_MITTWALD" | "COULD_BE_MITTWALD";
9276
9066
  type ContainerVolumeSortOrder = "nameAsc" | "nameDesc" | "storageAsc" | "storageDesc";
9277
- interface PollUserPollSettings {
9278
- completedAt?: string;
9279
- dontShowUntil?: string;
9280
- ignoredAt?: string;
9281
- shouldShow: boolean;
9282
- status: "completed" | "muted" | "ignored" | "new";
9283
- userId: string;
9284
- }
9285
9067
  interface CommonsAddress {
9286
9068
  street: string;
9287
9069
  houseNumber: string;
@@ -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,14 +25678,14 @@ export declare namespace MittwaldAPIV2 {
25898
25678
  }
25899
25679
  }
25900
25680
  }
25901
- namespace $404 {
25681
+ namespace $429 {
25902
25682
  namespace Content {
25903
25683
  interface ApplicationJson {
25904
25684
  [k: string]: unknown;
25905
25685
  }
25906
25686
  }
25907
25687
  }
25908
- namespace $429 {
25688
+ namespace $500 {
25909
25689
  namespace Content {
25910
25690
  interface ApplicationJson {
25911
25691
  [k: string]: unknown;
@@ -25921,23 +25701,24 @@ export declare namespace MittwaldAPIV2 {
25921
25701
  }
25922
25702
  }
25923
25703
  }
25924
- namespace Post {
25704
+ }
25705
+ namespace V2ProjectsProjectIdLicenses {
25706
+ namespace Get {
25925
25707
  namespace Parameters {
25926
25708
  type Path = {
25927
- customerId: string;
25709
+ projectId: string;
25710
+ };
25711
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
25712
+ type Query = {
25713
+ limit?: number;
25714
+ skip?: number;
25715
+ page?: number;
25928
25716
  };
25929
- interface RequestBody {
25930
- domain: string;
25931
- }
25932
- type Header = {};
25933
- type Query = {};
25934
25717
  }
25935
25718
  namespace Responses {
25936
- namespace $201 {
25719
+ namespace $200 {
25937
25720
  namespace Content {
25938
- interface ApplicationJson {
25939
- profileId: string;
25940
- }
25721
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.LicenseLicense[];
25941
25722
  }
25942
25723
  }
25943
25724
  namespace $400 {
@@ -25954,21 +25735,14 @@ export declare namespace MittwaldAPIV2 {
25954
25735
  }
25955
25736
  }
25956
25737
  }
25957
- namespace $404 {
25958
- namespace Content {
25959
- interface ApplicationJson {
25960
- [k: string]: unknown;
25961
- }
25962
- }
25963
- }
25964
- namespace $409 {
25738
+ namespace $429 {
25965
25739
  namespace Content {
25966
25740
  interface ApplicationJson {
25967
25741
  [k: string]: unknown;
25968
25742
  }
25969
25743
  }
25970
25744
  }
25971
- namespace $429 {
25745
+ namespace $500 {
25972
25746
  namespace Content {
25973
25747
  interface ApplicationJson {
25974
25748
  [k: string]: unknown;
@@ -25985,41 +25759,25 @@ export declare namespace MittwaldAPIV2 {
25985
25759
  }
25986
25760
  }
25987
25761
  }
25988
- namespace ExperimentalV2CustomersCustomerIdUnlockedLeadsExport { }
25989
- namespace V2ExperimentalCustomersCustomerIdUnlockedLeadsExport { }
25990
- namespace V2CustomersCustomerIdUnlockedLeadsExport {
25762
+ namespace V2LicensesLicenseIdActionsRotateKey {
25991
25763
  namespace Post {
25992
25764
  namespace Parameters {
25993
25765
  type Path = {
25994
- customerId: string;
25766
+ licenseId: string;
25995
25767
  };
25768
+ /**
25769
+ * Optional reference to a file containing the new key if it was not procured via mittwald.
25770
+ */
25996
25771
  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")[];
25772
+ externalKey?: string;
26005
25773
  }
26006
- type Header = {};
25774
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26007
25775
  type Query = {};
26008
25776
  }
26009
25777
  namespace Responses {
26010
25778
  namespace $200 {
26011
25779
  namespace Content {
26012
- interface ApplicationJson {
26013
- /**
26014
- * The base64 encoded csv content of the export.
26015
- */
26016
- contentBase64: string;
26017
- exportId: string;
26018
- }
26019
- /**
26020
- * The csv content of the export.
26021
- */
26022
- type TextCsv = string;
25780
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.LicenseKeyResponse;
26023
25781
  }
26024
25782
  }
26025
25783
  namespace $400 {
@@ -26043,7 +25801,7 @@ export declare namespace MittwaldAPIV2 {
26043
25801
  }
26044
25802
  }
26045
25803
  }
26046
- namespace $409 {
25804
+ namespace $412 {
26047
25805
  namespace Content {
26048
25806
  interface ApplicationJson {
26049
25807
  [k: string]: unknown;
@@ -26057,55 +25815,7 @@ export declare namespace MittwaldAPIV2 {
26057
25815
  }
26058
25816
  }
26059
25817
  }
26060
- namespace Default {
26061
- namespace Content {
26062
- interface ApplicationJson {
26063
- [k: string]: unknown;
26064
- }
26065
- }
26066
- }
26067
- }
26068
- }
26069
- }
26070
- namespace ExperimentalV2Cities { }
26071
- namespace V2ExperimentalCities { }
26072
- namespace V2Cities {
26073
- namespace Get {
26074
- namespace Parameters {
26075
- type Path = {};
26076
- type Header = {};
26077
- type Query = {
26078
- input: string;
26079
- };
26080
- }
26081
- namespace Responses {
26082
- namespace $200 {
26083
- namespace Content {
26084
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LeadfyndrCity[];
26085
- }
26086
- }
26087
- namespace $400 {
26088
- namespace Content {
26089
- interface ApplicationJson {
26090
- [k: string]: unknown;
26091
- }
26092
- }
26093
- }
26094
- namespace $403 {
26095
- namespace Content {
26096
- interface ApplicationJson {
26097
- [k: string]: unknown;
26098
- }
26099
- }
26100
- }
26101
- namespace $404 {
26102
- namespace Content {
26103
- interface ApplicationJson {
26104
- [k: string]: unknown;
26105
- }
26106
- }
26107
- }
26108
- namespace $429 {
25818
+ namespace $500 {
26109
25819
  namespace Content {
26110
25820
  interface ApplicationJson {
26111
25821
  [k: string]: unknown;
@@ -26122,80 +25832,30 @@ export declare namespace MittwaldAPIV2 {
26122
25832
  }
26123
25833
  }
26124
25834
  }
26125
- namespace ExperimentalV2CustomersCustomerIdLeadFyndrProfileTariff { }
26126
- namespace V2ExperimentalCustomersCustomerIdLeadFyndrProfileTariff { }
26127
- namespace V2CustomersCustomerIdLeadFyndrProfileTariff {
26128
- namespace Get {
25835
+ namespace V2ProjectsProjectIdActionsValidateLicenseKey {
25836
+ namespace Post {
26129
25837
  namespace Parameters {
26130
25838
  type Path = {
26131
- customerId: string;
25839
+ projectId: string;
26132
25840
  };
26133
- type Header = {};
25841
+ /**
25842
+ * The License key to validate.
25843
+ */
25844
+ interface RequestBody {
25845
+ key: string;
25846
+ kind: MittwaldAPIV2.Components.Schemas.LicenseKind;
25847
+ }
25848
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26134
25849
  type Query = {};
26135
25850
  }
26136
25851
  namespace Responses {
26137
25852
  namespace $200 {
26138
- namespace Content {
26139
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LeadfyndrTariffOptions;
26140
- }
26141
- }
26142
- namespace $400 {
26143
- namespace Content {
26144
- interface ApplicationJson {
26145
- [k: string]: unknown;
26146
- }
26147
- }
26148
- }
26149
- namespace $403 {
26150
- namespace Content {
26151
- interface ApplicationJson {
26152
- [k: string]: unknown;
26153
- }
26154
- }
26155
- }
26156
- namespace $404 {
26157
25853
  namespace Content {
26158
25854
  interface ApplicationJson {
26159
- [k: string]: unknown;
26160
- }
26161
- }
26162
- }
26163
- namespace $429 {
26164
- namespace Content {
26165
- interface ApplicationJson {
26166
- [k: string]: unknown;
26167
- }
26168
- }
26169
- }
26170
- namespace Default {
26171
- namespace Content {
26172
- interface ApplicationJson {
26173
- [k: string]: unknown;
25855
+ valid: boolean;
26174
25856
  }
26175
25857
  }
26176
25858
  }
26177
- }
26178
- }
26179
- }
26180
- namespace ExperimentalV2CustomersCustomerIdLeadFyndrProfile { }
26181
- namespace V2ExperimentalCustomersCustomerIdLeadFyndrProfile { }
26182
- namespace V2CustomersCustomerIdLeadFyndrProfile {
26183
- namespace Get {
26184
- namespace Parameters {
26185
- type Path = {
26186
- customerId: string;
26187
- };
26188
- type Header = {};
26189
- type Query = {};
26190
- }
26191
- namespace Responses {
26192
- namespace $200 {
26193
- namespace Content {
26194
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LeadfyndrProfile & {
26195
- tariff: MittwaldAPIV2.Components.Schemas.LeadfyndrTariffOptions;
26196
- };
26197
- }
26198
- }
26199
25859
  namespace $400 {
26200
25860
  namespace Content {
26201
25861
  interface ApplicationJson {
@@ -26217,63 +25877,21 @@ export declare namespace MittwaldAPIV2 {
26217
25877
  }
26218
25878
  }
26219
25879
  }
26220
- namespace $429 {
26221
- namespace Content {
26222
- interface ApplicationJson {
26223
- [k: string]: unknown;
26224
- }
26225
- }
26226
- }
26227
- namespace Default {
26228
- namespace Content {
26229
- interface ApplicationJson {
26230
- [k: string]: unknown;
26231
- }
26232
- }
26233
- }
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 {
26256
- namespace Content {
26257
- interface ApplicationJson {
26258
- [k: string]: unknown;
26259
- }
26260
- }
26261
- }
26262
- namespace $403 {
25880
+ namespace $412 {
26263
25881
  namespace Content {
26264
25882
  interface ApplicationJson {
26265
25883
  [k: string]: unknown;
26266
25884
  }
26267
25885
  }
26268
25886
  }
26269
- namespace $404 {
25887
+ namespace $429 {
26270
25888
  namespace Content {
26271
25889
  interface ApplicationJson {
26272
25890
  [k: string]: unknown;
26273
25891
  }
26274
25892
  }
26275
25893
  }
26276
- namespace $429 {
25894
+ namespace $500 {
26277
25895
  namespace Content {
26278
25896
  interface ApplicationJson {
26279
25897
  [k: string]: unknown;
@@ -26290,27 +25908,25 @@ export declare namespace MittwaldAPIV2 {
26290
25908
  }
26291
25909
  }
26292
25910
  }
26293
- namespace ExperimentalV2CustomersCustomerIdUnlockedLeadsExports { }
26294
- namespace V2ExperimentalCustomersCustomerIdUnlockedLeadsExports { }
26295
- namespace V2CustomersCustomerIdUnlockedLeadsExports {
25911
+ namespace V2ProjectsProjectIdDeliveryboxes { }
25912
+ namespace V2ProjectsProjectIdDeliveryBoxes {
26296
25913
  namespace Get {
26297
25914
  namespace Parameters {
26298
25915
  type Path = {
26299
- customerId: string;
25916
+ projectId: string;
26300
25917
  };
26301
- type Header = {};
25918
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26302
25919
  type Query = {
25920
+ search?: string;
26303
25921
  limit?: number;
26304
25922
  skip?: number;
26305
25923
  page?: number;
26306
- sort?: "exportedAt";
26307
- order?: "asc" | "desc";
26308
25924
  };
26309
25925
  }
26310
25926
  namespace Responses {
26311
25927
  namespace $200 {
26312
25928
  namespace Content {
26313
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LeadfyndrLeadsExport[];
25929
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailDeliverybox[];
26314
25930
  }
26315
25931
  }
26316
25932
  namespace $400 {
@@ -26341,56 +25957,14 @@ export declare namespace MittwaldAPIV2 {
26341
25957
  }
26342
25958
  }
26343
25959
  }
26344
- namespace Default {
26345
- namespace Content {
26346
- interface ApplicationJson {
26347
- [k: string]: unknown;
26348
- }
26349
- }
26350
- }
26351
- }
26352
- }
26353
- }
26354
- namespace ExperimentalV2CustomersCustomerIdUnlockedLeadsLeadId { }
26355
- namespace V2ExperimentalCustomersCustomerIdUnlockedLeadsLeadId { }
26356
- namespace V2CustomersCustomerIdUnlockedLeadsLeadId {
26357
- namespace Get {
26358
- namespace Parameters {
26359
- type Path = {
26360
- leadId: string;
26361
- customerId: string;
26362
- };
26363
- type Header = {};
26364
- type Query = {};
26365
- }
26366
- namespace Responses {
26367
- namespace $200 {
26368
- namespace Content {
26369
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LeadfyndrUnlockedLead;
26370
- }
26371
- }
26372
- namespace $400 {
26373
- namespace Content {
26374
- interface ApplicationJson {
26375
- [k: string]: unknown;
26376
- }
26377
- }
26378
- }
26379
- namespace $403 {
26380
- namespace Content {
26381
- interface ApplicationJson {
26382
- [k: string]: unknown;
26383
- }
26384
- }
26385
- }
26386
- namespace $404 {
25960
+ namespace $500 {
26387
25961
  namespace Content {
26388
25962
  interface ApplicationJson {
26389
25963
  [k: string]: unknown;
26390
25964
  }
26391
25965
  }
26392
25966
  }
26393
- namespace $429 {
25967
+ namespace $503 {
26394
25968
  namespace Content {
26395
25969
  interface ApplicationJson {
26396
25970
  [k: string]: unknown;
@@ -26409,17 +25983,23 @@ export declare namespace MittwaldAPIV2 {
26409
25983
  namespace Post {
26410
25984
  namespace Parameters {
26411
25985
  type Path = {
26412
- leadId: string;
26413
- customerId: string;
25986
+ projectId: string;
26414
25987
  };
26415
- 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;
26416
25996
  type Query = {};
26417
25997
  }
26418
25998
  namespace Responses {
26419
- namespace $200 {
25999
+ namespace $201 {
26420
26000
  namespace Content {
26421
26001
  interface ApplicationJson {
26422
- leadId: string;
26002
+ id: string;
26423
26003
  }
26424
26004
  }
26425
26005
  }
@@ -26451,72 +26031,14 @@ export declare namespace MittwaldAPIV2 {
26451
26031
  }
26452
26032
  }
26453
26033
  }
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 {
26034
+ namespace $500 {
26513
26035
  namespace Content {
26514
26036
  interface ApplicationJson {
26515
26037
  [k: string]: unknown;
26516
26038
  }
26517
26039
  }
26518
26040
  }
26519
- namespace $429 {
26041
+ namespace $503 {
26520
26042
  namespace Content {
26521
26043
  interface ApplicationJson {
26522
26044
  [k: string]: unknown;
@@ -26533,53 +26055,31 @@ export declare namespace MittwaldAPIV2 {
26533
26055
  }
26534
26056
  }
26535
26057
  }
26536
- namespace ExperimentalV2CustomersCustomerIdUnlockedLeads { }
26537
- namespace V2ExperimentalCustomersCustomerIdUnlockedLeads { }
26538
- namespace V2CustomersCustomerIdUnlockedLeads {
26058
+ namespace V2ProjectsProjectIdMailaddresses { }
26059
+ namespace V2ProjectsProjectIdMailAddresses {
26539
26060
  namespace Get {
26540
26061
  namespace Parameters {
26541
26062
  type Path = {
26542
- customerId: string;
26063
+ projectId: string;
26543
26064
  };
26544
- type Header = {};
26065
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26545
26066
  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;
26067
+ search?: string;
26068
+ forwardAddress?: boolean;
26069
+ catchAll?: boolean;
26070
+ autoResponder?: boolean;
26071
+ mailArchive?: boolean;
26567
26072
  limit?: number;
26568
26073
  skip?: number;
26569
26074
  page?: number;
26570
- sort?: "potential" | "relevance" | "company";
26571
- order?: "asc" | "desc";
26075
+ sort?: ("address.domain" | "address.local" | "updatedAt" | "projectId" | "mailbox.quota" | "mailbox.name" | "mailbox.storageInBytes.current" | "mailbox.storageInBytes.limit")[];
26076
+ order?: ("asc" | "desc")[];
26572
26077
  };
26573
26078
  }
26574
26079
  namespace Responses {
26575
26080
  namespace $200 {
26576
26081
  namespace Content {
26577
- interface ApplicationJson {
26578
- leads: MittwaldAPIV2.Components.Schemas.LeadfyndrUnlockedLead[];
26579
- limit: number;
26580
- skip: number;
26581
- totalCount: number;
26582
- }
26082
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailMailAddress[];
26583
26083
  }
26584
26084
  }
26585
26085
  namespace $400 {
@@ -26610,6 +26110,20 @@ export declare namespace MittwaldAPIV2 {
26610
26110
  }
26611
26111
  }
26612
26112
  }
26113
+ namespace $500 {
26114
+ namespace Content {
26115
+ interface ApplicationJson {
26116
+ [k: string]: unknown;
26117
+ }
26118
+ }
26119
+ }
26120
+ namespace $503 {
26121
+ namespace Content {
26122
+ interface ApplicationJson {
26123
+ [k: string]: unknown;
26124
+ }
26125
+ }
26126
+ }
26613
26127
  namespace Default {
26614
26128
  namespace Content {
26615
26129
  interface ApplicationJson {
@@ -26619,24 +26133,20 @@ export declare namespace MittwaldAPIV2 {
26619
26133
  }
26620
26134
  }
26621
26135
  }
26622
- }
26623
- namespace ExperimentalV2CustomersCustomerIdUnlockedLeadsLeadIdReservation { }
26624
- namespace V2ExperimentalCustomersCustomerIdUnlockedLeadsLeadIdReservation { }
26625
- namespace V2CustomersCustomerIdUnlockedLeadsLeadIdReservation {
26626
26136
  namespace Post {
26627
26137
  namespace Parameters {
26628
26138
  type Path = {
26629
- leadId: string;
26630
- customerId: string;
26139
+ projectId: string;
26631
26140
  };
26632
- type Header = {};
26141
+ type RequestBody = MittwaldAPIV2.Components.Schemas.MailCreateForwardAddress | MittwaldAPIV2.Components.Schemas.MailCreateMailAddress;
26142
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26633
26143
  type Query = {};
26634
26144
  }
26635
26145
  namespace Responses {
26636
- namespace $200 {
26146
+ namespace $201 {
26637
26147
  namespace Content {
26638
26148
  interface ApplicationJson {
26639
- leadId: string;
26149
+ id: string;
26640
26150
  }
26641
26151
  }
26642
26152
  }
@@ -26661,14 +26171,21 @@ export declare namespace MittwaldAPIV2 {
26661
26171
  }
26662
26172
  }
26663
26173
  }
26664
- namespace $409 {
26174
+ namespace $429 {
26665
26175
  namespace Content {
26666
26176
  interface ApplicationJson {
26667
26177
  [k: string]: unknown;
26668
26178
  }
26669
26179
  }
26670
26180
  }
26671
- namespace $429 {
26181
+ namespace $500 {
26182
+ namespace Content {
26183
+ interface ApplicationJson {
26184
+ [k: string]: unknown;
26185
+ }
26186
+ }
26187
+ }
26188
+ namespace $503 {
26672
26189
  namespace Content {
26673
26190
  interface ApplicationJson {
26674
26191
  [k: string]: unknown;
@@ -26684,21 +26201,21 @@ export declare namespace MittwaldAPIV2 {
26684
26201
  }
26685
26202
  }
26686
26203
  }
26687
- namespace Delete {
26204
+ }
26205
+ namespace V2DeliveryboxesDeliveryBoxId { }
26206
+ namespace V2DeliveryBoxesDeliveryBoxId {
26207
+ namespace Get {
26688
26208
  namespace Parameters {
26689
26209
  type Path = {
26690
- leadId: string;
26691
- customerId: string;
26210
+ deliveryBoxId: string;
26692
26211
  };
26693
- type Header = {};
26212
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26694
26213
  type Query = {};
26695
26214
  }
26696
26215
  namespace Responses {
26697
26216
  namespace $200 {
26698
26217
  namespace Content {
26699
- interface ApplicationJson {
26700
- leadId: string;
26701
- }
26218
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailDeliverybox;
26702
26219
  }
26703
26220
  }
26704
26221
  namespace $400 {
@@ -26722,14 +26239,21 @@ export declare namespace MittwaldAPIV2 {
26722
26239
  }
26723
26240
  }
26724
26241
  }
26725
- namespace $409 {
26242
+ namespace $429 {
26726
26243
  namespace Content {
26727
26244
  interface ApplicationJson {
26728
26245
  [k: string]: unknown;
26729
26246
  }
26730
26247
  }
26731
26248
  }
26732
- namespace $429 {
26249
+ namespace $500 {
26250
+ namespace Content {
26251
+ interface ApplicationJson {
26252
+ [k: string]: unknown;
26253
+ }
26254
+ }
26255
+ }
26256
+ namespace $503 {
26733
26257
  namespace Content {
26734
26258
  interface ApplicationJson {
26735
26259
  [k: string]: unknown;
@@ -26745,20 +26269,18 @@ export declare namespace MittwaldAPIV2 {
26745
26269
  }
26746
26270
  }
26747
26271
  }
26748
- }
26749
- namespace V2LicensesLicenseId {
26750
- namespace Get {
26272
+ namespace Delete {
26751
26273
  namespace Parameters {
26752
26274
  type Path = {
26753
- licenseId: string;
26275
+ deliveryBoxId: string;
26754
26276
  };
26755
26277
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26756
26278
  type Query = {};
26757
26279
  }
26758
26280
  namespace Responses {
26759
- namespace $200 {
26281
+ namespace $204 {
26760
26282
  namespace Content {
26761
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LicenseLicense;
26283
+ type Empty = unknown;
26762
26284
  }
26763
26285
  }
26764
26286
  namespace $400 {
@@ -26775,6 +26297,13 @@ export declare namespace MittwaldAPIV2 {
26775
26297
  }
26776
26298
  }
26777
26299
  }
26300
+ namespace $404 {
26301
+ namespace Content {
26302
+ interface ApplicationJson {
26303
+ [k: string]: unknown;
26304
+ }
26305
+ }
26306
+ }
26778
26307
  namespace $429 {
26779
26308
  namespace Content {
26780
26309
  interface ApplicationJson {
@@ -26789,6 +26318,13 @@ export declare namespace MittwaldAPIV2 {
26789
26318
  }
26790
26319
  }
26791
26320
  }
26321
+ namespace $503 {
26322
+ namespace Content {
26323
+ interface ApplicationJson {
26324
+ [k: string]: unknown;
26325
+ }
26326
+ }
26327
+ }
26792
26328
  namespace Default {
26793
26329
  namespace Content {
26794
26330
  interface ApplicationJson {
@@ -26799,23 +26335,20 @@ export declare namespace MittwaldAPIV2 {
26799
26335
  }
26800
26336
  }
26801
26337
  }
26802
- namespace V2ProjectsProjectIdLicenses {
26338
+ namespace V2MailaddressesMailAddressId { }
26339
+ namespace V2MailAddressesMailAddressId {
26803
26340
  namespace Get {
26804
26341
  namespace Parameters {
26805
26342
  type Path = {
26806
- projectId: string;
26343
+ mailAddressId: string;
26807
26344
  };
26808
26345
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26809
- type Query = {
26810
- limit?: number;
26811
- skip?: number;
26812
- page?: number;
26813
- };
26346
+ type Query = {};
26814
26347
  }
26815
26348
  namespace Responses {
26816
26349
  namespace $200 {
26817
26350
  namespace Content {
26818
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LicenseLicense[];
26351
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailMailAddress;
26819
26352
  }
26820
26353
  }
26821
26354
  namespace $400 {
@@ -26832,6 +26365,13 @@ export declare namespace MittwaldAPIV2 {
26832
26365
  }
26833
26366
  }
26834
26367
  }
26368
+ namespace $404 {
26369
+ namespace Content {
26370
+ interface ApplicationJson {
26371
+ [k: string]: unknown;
26372
+ }
26373
+ }
26374
+ }
26835
26375
  namespace $429 {
26836
26376
  namespace Content {
26837
26377
  interface ApplicationJson {
@@ -26846,6 +26386,13 @@ export declare namespace MittwaldAPIV2 {
26846
26386
  }
26847
26387
  }
26848
26388
  }
26389
+ namespace $503 {
26390
+ namespace Content {
26391
+ interface ApplicationJson {
26392
+ [k: string]: unknown;
26393
+ }
26394
+ }
26395
+ }
26849
26396
  namespace Default {
26850
26397
  namespace Content {
26851
26398
  interface ApplicationJson {
@@ -26855,26 +26402,18 @@ export declare namespace MittwaldAPIV2 {
26855
26402
  }
26856
26403
  }
26857
26404
  }
26858
- }
26859
- namespace V2LicensesLicenseIdActionsRotateKey {
26860
- namespace Post {
26405
+ namespace Delete {
26861
26406
  namespace Parameters {
26862
26407
  type Path = {
26863
- licenseId: string;
26408
+ mailAddressId: string;
26864
26409
  };
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
- }
26871
26410
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26872
26411
  type Query = {};
26873
26412
  }
26874
26413
  namespace Responses {
26875
- namespace $200 {
26414
+ namespace $204 {
26876
26415
  namespace Content {
26877
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.LicenseKeyResponse;
26416
+ type Empty = unknown;
26878
26417
  }
26879
26418
  }
26880
26419
  namespace $400 {
@@ -26898,21 +26437,21 @@ export declare namespace MittwaldAPIV2 {
26898
26437
  }
26899
26438
  }
26900
26439
  }
26901
- namespace $412 {
26440
+ namespace $429 {
26902
26441
  namespace Content {
26903
26442
  interface ApplicationJson {
26904
26443
  [k: string]: unknown;
26905
26444
  }
26906
26445
  }
26907
26446
  }
26908
- namespace $429 {
26447
+ namespace $500 {
26909
26448
  namespace Content {
26910
26449
  interface ApplicationJson {
26911
26450
  [k: string]: unknown;
26912
26451
  }
26913
26452
  }
26914
26453
  }
26915
- namespace $500 {
26454
+ namespace $503 {
26916
26455
  namespace Content {
26917
26456
  interface ApplicationJson {
26918
26457
  [k: string]: unknown;
@@ -26929,28 +26468,19 @@ export declare namespace MittwaldAPIV2 {
26929
26468
  }
26930
26469
  }
26931
26470
  }
26932
- namespace V2ProjectsProjectIdActionsValidateLicenseKey {
26933
- namespace Post {
26471
+ namespace V2MailAddressesMailAddressIdMailArchive {
26472
+ namespace Delete {
26934
26473
  namespace Parameters {
26935
26474
  type Path = {
26936
- projectId: string;
26475
+ mailAddressId: string;
26937
26476
  };
26938
- /**
26939
- * The License key to validate.
26940
- */
26941
- interface RequestBody {
26942
- key: string;
26943
- kind: MittwaldAPIV2.Components.Schemas.LicenseKind;
26944
- }
26945
26477
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
26946
26478
  type Query = {};
26947
26479
  }
26948
26480
  namespace Responses {
26949
- namespace $200 {
26481
+ namespace $204 {
26950
26482
  namespace Content {
26951
- interface ApplicationJson {
26952
- valid: boolean;
26953
- }
26483
+ type Empty = unknown;
26954
26484
  }
26955
26485
  }
26956
26486
  namespace $400 {
@@ -26974,21 +26504,21 @@ export declare namespace MittwaldAPIV2 {
26974
26504
  }
26975
26505
  }
26976
26506
  }
26977
- namespace $412 {
26507
+ namespace $429 {
26978
26508
  namespace Content {
26979
26509
  interface ApplicationJson {
26980
26510
  [k: string]: unknown;
26981
26511
  }
26982
26512
  }
26983
26513
  }
26984
- namespace $429 {
26514
+ namespace $500 {
26985
26515
  namespace Content {
26986
26516
  interface ApplicationJson {
26987
26517
  [k: string]: unknown;
26988
26518
  }
26989
26519
  }
26990
26520
  }
26991
- namespace $500 {
26521
+ namespace $503 {
26992
26522
  namespace Content {
26993
26523
  interface ApplicationJson {
26994
26524
  [k: string]: unknown;
@@ -27005,39 +26535,19 @@ export declare namespace MittwaldAPIV2 {
27005
26535
  }
27006
26536
  }
27007
26537
  }
27008
- namespace V2ProjectsProjectIdDeliveryboxes { }
27009
- namespace V2ProjectsProjectIdDeliveryBoxes {
26538
+ namespace V2MailRateLimitsMailRateLimitId {
27010
26539
  namespace Get {
27011
26540
  namespace Parameters {
27012
26541
  type Path = {
27013
- projectId: string;
26542
+ mailRateLimitId: string;
27014
26543
  };
27015
26544
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27016
- type Query = {
27017
- search?: string;
27018
- limit?: number;
27019
- skip?: number;
27020
- page?: number;
27021
- };
26545
+ type Query = {};
27022
26546
  }
27023
26547
  namespace Responses {
27024
26548
  namespace $200 {
27025
26549
  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
- }
26550
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailsystemRateLimit;
27041
26551
  }
27042
26552
  }
27043
26553
  namespace $404 {
@@ -27054,20 +26564,6 @@ export declare namespace MittwaldAPIV2 {
27054
26564
  }
27055
26565
  }
27056
26566
  }
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
26567
  namespace Default {
27072
26568
  namespace Content {
27073
26569
  interface ApplicationJson {
@@ -27077,27 +26573,20 @@ export declare namespace MittwaldAPIV2 {
27077
26573
  }
27078
26574
  }
27079
26575
  }
27080
- namespace Post {
26576
+ }
26577
+ namespace V2MailAddressesMailAddressIdBackups {
26578
+ namespace Get {
27081
26579
  namespace Parameters {
27082
26580
  type Path = {
27083
- projectId: string;
26581
+ mailAddressId: string;
27084
26582
  };
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
26583
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27093
26584
  type Query = {};
27094
26585
  }
27095
26586
  namespace Responses {
27096
- namespace $201 {
26587
+ namespace $200 {
27097
26588
  namespace Content {
27098
- interface ApplicationJson {
27099
- id: string;
27100
- }
26589
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailMailAddressBackup[];
27101
26590
  }
27102
26591
  }
27103
26592
  namespace $400 {
@@ -27135,13 +26624,6 @@ export declare namespace MittwaldAPIV2 {
27135
26624
  }
27136
26625
  }
27137
26626
  }
27138
- namespace $503 {
27139
- namespace Content {
27140
- interface ApplicationJson {
27141
- [k: string]: unknown;
27142
- }
27143
- }
27144
- }
27145
26627
  namespace Default {
27146
26628
  namespace Content {
27147
26629
  interface ApplicationJson {
@@ -27152,15 +26634,13 @@ export declare namespace MittwaldAPIV2 {
27152
26634
  }
27153
26635
  }
27154
26636
  }
27155
- namespace V2ProjectsProjectIdMailaddresses { }
27156
- namespace V2ProjectsProjectIdMailAddresses {
26637
+ namespace V2MailAddresses {
27157
26638
  namespace Get {
27158
26639
  namespace Parameters {
27159
- type Path = {
27160
- projectId: string;
27161
- };
26640
+ type Path = {};
27162
26641
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27163
26642
  type Query = {
26643
+ projectId?: string;
27164
26644
  search?: string;
27165
26645
  forwardAddress?: boolean;
27166
26646
  catchAll?: boolean;
@@ -27230,42 +26710,18 @@ export declare namespace MittwaldAPIV2 {
27230
26710
  }
27231
26711
  }
27232
26712
  }
27233
- namespace Post {
26713
+ }
26714
+ namespace V2MailRateLimits {
26715
+ namespace Get {
27234
26716
  namespace Parameters {
27235
- type Path = {
27236
- projectId: string;
27237
- };
27238
- type RequestBody = MittwaldAPIV2.Components.Schemas.MailCreateForwardAddress | MittwaldAPIV2.Components.Schemas.MailCreateMailAddress;
26717
+ type Path = {};
27239
26718
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27240
26719
  type Query = {};
27241
26720
  }
27242
26721
  namespace Responses {
27243
- namespace $201 {
27244
- namespace Content {
27245
- interface ApplicationJson {
27246
- id: string;
27247
- }
27248
- }
27249
- }
27250
- namespace $400 {
27251
- namespace Content {
27252
- interface ApplicationJson {
27253
- [k: string]: unknown;
27254
- }
27255
- }
27256
- }
27257
- namespace $403 {
27258
- namespace Content {
27259
- interface ApplicationJson {
27260
- [k: string]: unknown;
27261
- }
27262
- }
27263
- }
27264
- namespace $404 {
26722
+ namespace $200 {
27265
26723
  namespace Content {
27266
- interface ApplicationJson {
27267
- [k: string]: unknown;
27268
- }
26724
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailsystemRateLimit[];
27269
26725
  }
27270
26726
  }
27271
26727
  namespace $429 {
@@ -27275,20 +26731,6 @@ export declare namespace MittwaldAPIV2 {
27275
26731
  }
27276
26732
  }
27277
26733
  }
27278
- namespace $500 {
27279
- namespace Content {
27280
- interface ApplicationJson {
27281
- [k: string]: unknown;
27282
- }
27283
- }
27284
- }
27285
- namespace $503 {
27286
- namespace Content {
27287
- interface ApplicationJson {
27288
- [k: string]: unknown;
27289
- }
27290
- }
27291
- }
27292
26734
  namespace Default {
27293
26735
  namespace Content {
27294
26736
  interface ApplicationJson {
@@ -27299,12 +26741,12 @@ export declare namespace MittwaldAPIV2 {
27299
26741
  }
27300
26742
  }
27301
26743
  }
27302
- namespace V2DeliveryboxesDeliveryBoxId { }
27303
- namespace V2DeliveryBoxesDeliveryBoxId {
26744
+ namespace V2ProjectsProjectIdMailsettings { }
26745
+ namespace V2ProjectsProjectIdMailSettings {
27304
26746
  namespace Get {
27305
26747
  namespace Parameters {
27306
26748
  type Path = {
27307
- deliveryBoxId: string;
26749
+ projectId: string;
27308
26750
  };
27309
26751
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27310
26752
  type Query = {};
@@ -27312,7 +26754,11 @@ export declare namespace MittwaldAPIV2 {
27312
26754
  namespace Responses {
27313
26755
  namespace $200 {
27314
26756
  namespace Content {
27315
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailDeliverybox;
26757
+ interface ApplicationJson {
26758
+ blacklist: string[];
26759
+ projectId: string;
26760
+ whitelist: string[];
26761
+ }
27316
26762
  }
27317
26763
  }
27318
26764
  namespace $400 {
@@ -27366,10 +26812,13 @@ export declare namespace MittwaldAPIV2 {
27366
26812
  }
27367
26813
  }
27368
26814
  }
27369
- namespace Delete {
26815
+ }
26816
+ namespace V2MailAddressesMailAddressIdBackupsBackupIdRecovery {
26817
+ namespace Post {
27370
26818
  namespace Parameters {
27371
26819
  type Path = {
27372
- deliveryBoxId: string;
26820
+ mailAddressId: string;
26821
+ backupId: string;
27373
26822
  };
27374
26823
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27375
26824
  type Query = {};
@@ -27387,13 +26836,6 @@ export declare namespace MittwaldAPIV2 {
27387
26836
  }
27388
26837
  }
27389
26838
  }
27390
- namespace $403 {
27391
- namespace Content {
27392
- interface ApplicationJson {
27393
- [k: string]: unknown;
27394
- }
27395
- }
27396
- }
27397
26839
  namespace $404 {
27398
26840
  namespace Content {
27399
26841
  interface ApplicationJson {
@@ -27408,20 +26850,6 @@ export declare namespace MittwaldAPIV2 {
27408
26850
  }
27409
26851
  }
27410
26852
  }
27411
- namespace $500 {
27412
- namespace Content {
27413
- interface ApplicationJson {
27414
- [k: string]: unknown;
27415
- }
27416
- }
27417
- }
27418
- namespace $503 {
27419
- namespace Content {
27420
- interface ApplicationJson {
27421
- [k: string]: unknown;
27422
- }
27423
- }
27424
- }
27425
26853
  namespace Default {
27426
26854
  namespace Content {
27427
26855
  interface ApplicationJson {
@@ -27432,20 +26860,22 @@ export declare namespace MittwaldAPIV2 {
27432
26860
  }
27433
26861
  }
27434
26862
  }
27435
- namespace V2MailaddressesMailAddressId { }
27436
- namespace V2MailAddressesMailAddressId {
27437
- namespace Get {
26863
+ namespace V2MailAddressesMailAddressIdActionsRequestRateLimitChange {
26864
+ namespace Post {
27438
26865
  namespace Parameters {
27439
26866
  type Path = {
27440
26867
  mailAddressId: string;
27441
26868
  };
26869
+ interface RequestBody {
26870
+ rateLimitId: string;
26871
+ }
27442
26872
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27443
26873
  type Query = {};
27444
26874
  }
27445
26875
  namespace Responses {
27446
- namespace $200 {
26876
+ namespace $204 {
27447
26877
  namespace Content {
27448
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailMailAddress;
26878
+ type Empty = unknown;
27449
26879
  }
27450
26880
  }
27451
26881
  namespace $400 {
@@ -27499,11 +26929,16 @@ export declare namespace MittwaldAPIV2 {
27499
26929
  }
27500
26930
  }
27501
26931
  }
27502
- namespace Delete {
26932
+ }
26933
+ namespace V2DeliveryBoxesDeliveryBoxIdDescription {
26934
+ namespace Patch {
27503
26935
  namespace Parameters {
27504
26936
  type Path = {
27505
- mailAddressId: string;
26937
+ deliveryBoxId: string;
27506
26938
  };
26939
+ interface RequestBody {
26940
+ description: string;
26941
+ }
27507
26942
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27508
26943
  type Query = {};
27509
26944
  }
@@ -27565,12 +27000,15 @@ export declare namespace MittwaldAPIV2 {
27565
27000
  }
27566
27001
  }
27567
27002
  }
27568
- namespace V2MailAddressesMailAddressIdMailArchive {
27569
- namespace Delete {
27003
+ namespace V2DeliveryBoxesDeliveryBoxIdPassword {
27004
+ namespace Patch {
27570
27005
  namespace Parameters {
27571
27006
  type Path = {
27572
- mailAddressId: string;
27007
+ deliveryBoxId: string;
27573
27008
  };
27009
+ interface RequestBody {
27010
+ password: string;
27011
+ }
27574
27012
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27575
27013
  type Query = {};
27576
27014
  }
@@ -27632,58 +27070,22 @@ export declare namespace MittwaldAPIV2 {
27632
27070
  }
27633
27071
  }
27634
27072
  }
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 {
27073
+ namespace V2MailAddressesMailAddressIdAddress {
27074
+ namespace Patch {
27676
27075
  namespace Parameters {
27677
27076
  type Path = {
27678
27077
  mailAddressId: string;
27679
27078
  };
27079
+ interface RequestBody {
27080
+ address: string;
27081
+ }
27680
27082
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27681
27083
  type Query = {};
27682
27084
  }
27683
27085
  namespace Responses {
27684
- namespace $200 {
27086
+ namespace $204 {
27685
27087
  namespace Content {
27686
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.MailMailAddressBackup[];
27088
+ type Empty = unknown;
27687
27089
  }
27688
27090
  }
27689
27091
  namespace $400 {
@@ -27721,6 +27123,13 @@ export declare namespace MittwaldAPIV2 {
27721
27123
  }
27722
27124
  }
27723
27125
  }
27126
+ namespace $503 {
27127
+ namespace Content {
27128
+ interface ApplicationJson {
27129
+ [k: string]: unknown;
27130
+ }
27131
+ }
27132
+ }
27724
27133
  namespace Default {
27725
27134
  namespace Content {
27726
27135
  interface ApplicationJson {
@@ -27731,528 +27140,22 @@ export declare namespace MittwaldAPIV2 {
27731
27140
  }
27732
27141
  }
27733
27142
  }
27734
- namespace V2MailAddresses {
27735
- namespace Get {
27143
+ namespace V2MailAddressesMailAddressIdCatchAll {
27144
+ namespace Patch {
27736
27145
  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")[];
27146
+ type Path = {
27147
+ mailAddressId: string;
27751
27148
  };
27149
+ interface RequestBody {
27150
+ active: boolean;
27151
+ }
27152
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
27153
+ type Query = {};
27752
27154
  }
27753
27155
  namespace Responses {
27754
- namespace $200 {
27156
+ namespace $204 {
27755
27157
  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
- }
28249
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
28250
- type Query = {};
28251
- }
28252
- namespace Responses {
28253
- namespace $204 {
28254
- namespace Content {
28255
- type Empty = unknown;
27158
+ type Empty = unknown;
28256
27159
  }
28257
27160
  }
28258
27161
  namespace $400 {
@@ -30661,6 +29564,13 @@ export declare namespace MittwaldAPIV2 {
30661
29564
  }
30662
29565
  }
30663
29566
  }
29567
+ namespace $412 {
29568
+ namespace Content {
29569
+ interface ApplicationJson {
29570
+ [k: string]: unknown;
29571
+ }
29572
+ }
29573
+ }
30664
29574
  namespace $429 {
30665
29575
  namespace Content {
30666
29576
  interface ApplicationJson {
@@ -30732,6 +29642,13 @@ export declare namespace MittwaldAPIV2 {
30732
29642
  }
30733
29643
  }
30734
29644
  }
29645
+ namespace $412 {
29646
+ namespace Content {
29647
+ interface ApplicationJson {
29648
+ [k: string]: unknown;
29649
+ }
29650
+ }
29651
+ }
30735
29652
  namespace $429 {
30736
29653
  namespace Content {
30737
29654
  interface ApplicationJson {
@@ -30896,6 +29813,13 @@ export declare namespace MittwaldAPIV2 {
30896
29813
  }
30897
29814
  }
30898
29815
  }
29816
+ namespace $412 {
29817
+ namespace Content {
29818
+ interface ApplicationJson {
29819
+ [k: string]: unknown;
29820
+ }
29821
+ }
29822
+ }
30899
29823
  namespace $429 {
30900
29824
  namespace Content {
30901
29825
  interface ApplicationJson {
@@ -30967,6 +29891,13 @@ export declare namespace MittwaldAPIV2 {
30967
29891
  }
30968
29892
  }
30969
29893
  }
29894
+ namespace $412 {
29895
+ namespace Content {
29896
+ interface ApplicationJson {
29897
+ [k: string]: unknown;
29898
+ }
29899
+ }
29900
+ }
30970
29901
  namespace $429 {
30971
29902
  namespace Content {
30972
29903
  interface ApplicationJson {
@@ -34172,32 +33103,314 @@ export declare namespace MittwaldAPIV2 {
34172
33103
  }
34173
33104
  }
34174
33105
  }
34175
- namespace Put {
33106
+ namespace Put {
33107
+ namespace Parameters {
33108
+ type Path = {
33109
+ sshKeyId: string;
33110
+ };
33111
+ interface RequestBody {
33112
+ comment: string;
33113
+ expiresAt?: string | Date;
33114
+ }
33115
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
33116
+ type Query = {};
33117
+ }
33118
+ namespace Responses {
33119
+ namespace $204 {
33120
+ namespace Content {
33121
+ type Empty = unknown;
33122
+ }
33123
+ }
33124
+ namespace $400 {
33125
+ namespace Content {
33126
+ interface ApplicationJson {
33127
+ [k: string]: unknown;
33128
+ }
33129
+ }
33130
+ }
33131
+ namespace $429 {
33132
+ namespace Content {
33133
+ interface ApplicationJson {
33134
+ [k: string]: unknown;
33135
+ }
33136
+ }
33137
+ }
33138
+ namespace Default {
33139
+ namespace Content {
33140
+ interface ApplicationJson {
33141
+ [k: string]: unknown;
33142
+ }
33143
+ }
33144
+ }
33145
+ }
33146
+ }
33147
+ namespace Delete {
33148
+ namespace Parameters {
33149
+ type Path = {
33150
+ sshKeyId: string;
33151
+ };
33152
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
33153
+ type Query = {};
33154
+ }
33155
+ namespace Responses {
33156
+ namespace $204 {
33157
+ namespace Content {
33158
+ type Empty = unknown;
33159
+ }
33160
+ }
33161
+ namespace $429 {
33162
+ namespace Content {
33163
+ interface ApplicationJson {
33164
+ [k: string]: unknown;
33165
+ }
33166
+ }
33167
+ }
33168
+ namespace Default {
33169
+ namespace Content {
33170
+ interface ApplicationJson {
33171
+ [k: string]: unknown;
33172
+ }
33173
+ }
33174
+ }
33175
+ }
33176
+ }
33177
+ }
33178
+ namespace V2UsersSelf {
33179
+ namespace Delete {
33180
+ namespace Parameters {
33181
+ type Path = {};
33182
+ interface RequestBody {
33183
+ /**
33184
+ * A TOTP code or recovery code.
33185
+ */
33186
+ multiFactorCode?: string;
33187
+ passkeyCredential?: MittwaldAPIV2.Components.Schemas.SignupPasskeyCredential;
33188
+ /**
33189
+ * The password of the user.
33190
+ */
33191
+ password: string;
33192
+ }
33193
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
33194
+ type Query = {};
33195
+ }
33196
+ namespace Responses {
33197
+ namespace $200 {
33198
+ namespace Content {
33199
+ type Empty = unknown;
33200
+ }
33201
+ }
33202
+ namespace $202 {
33203
+ namespace Content {
33204
+ interface ApplicationJson {
33205
+ [k: string]: unknown;
33206
+ }
33207
+ }
33208
+ }
33209
+ namespace $400 {
33210
+ namespace Content {
33211
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsValidationErrors;
33212
+ }
33213
+ }
33214
+ namespace $412 {
33215
+ namespace Content {
33216
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsError;
33217
+ }
33218
+ }
33219
+ namespace $429 {
33220
+ namespace Content {
33221
+ interface ApplicationJson {
33222
+ [k: string]: unknown;
33223
+ }
33224
+ }
33225
+ }
33226
+ namespace Default {
33227
+ namespace Content {
33228
+ interface ApplicationJson {
33229
+ [k: string]: unknown;
33230
+ }
33231
+ }
33232
+ }
33233
+ }
33234
+ }
33235
+ }
33236
+ namespace V2UsersSelfSessionsCurrentStatus {
33237
+ namespace Get {
33238
+ namespace Parameters {
33239
+ type Path = {};
33240
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
33241
+ type Query = {};
33242
+ }
33243
+ namespace Responses {
33244
+ namespace $200 {
33245
+ namespace Content {
33246
+ interface ApplicationJson {
33247
+ /**
33248
+ * Whether the executing user is an employee.
33249
+ */
33250
+ isEmployee: boolean;
33251
+ /**
33252
+ * Whether the current session is an impersonation.
33253
+ */
33254
+ isImpersonated: boolean;
33255
+ /**
33256
+ * The ID of the token currently in use.
33257
+ */
33258
+ tokenId: string;
33259
+ /**
33260
+ * ID of the executing user.
33261
+ */
33262
+ userId: string;
33263
+ }
33264
+ }
33265
+ }
33266
+ namespace $429 {
33267
+ namespace Content {
33268
+ interface ApplicationJson {
33269
+ [k: string]: unknown;
33270
+ }
33271
+ }
33272
+ }
33273
+ namespace Default {
33274
+ namespace Content {
33275
+ interface ApplicationJson {
33276
+ [k: string]: unknown;
33277
+ }
33278
+ }
33279
+ }
33280
+ }
33281
+ }
33282
+ }
33283
+ namespace V2UsersSelfCredentialsPasswordUpdatedAt {
33284
+ namespace Get {
33285
+ namespace Parameters {
33286
+ type Path = {};
33287
+ interface RequestBody {
33288
+ }
33289
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
33290
+ type Query = {};
33291
+ }
33292
+ namespace Responses {
33293
+ namespace $200 {
33294
+ namespace Content {
33295
+ interface ApplicationJson {
33296
+ passwordUpdatedAt: string;
33297
+ }
33298
+ }
33299
+ }
33300
+ namespace $429 {
33301
+ namespace Content {
33302
+ interface ApplicationJson {
33303
+ [k: string]: unknown;
33304
+ }
33305
+ }
33306
+ }
33307
+ namespace Default {
33308
+ namespace Content {
33309
+ interface ApplicationJson {
33310
+ [k: string]: unknown;
33311
+ }
33312
+ }
33313
+ }
33314
+ }
33315
+ }
33316
+ }
33317
+ namespace V2UsersUserIdSettings {
33318
+ namespace Get {
33319
+ namespace Parameters {
33320
+ type Path = {
33321
+ userId: string;
33322
+ };
33323
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
33324
+ type Query = {};
33325
+ }
33326
+ namespace Responses {
33327
+ namespace $200 {
33328
+ namespace Content {
33329
+ interface ApplicationJson {
33330
+ settingsString?: string;
33331
+ }
33332
+ }
33333
+ }
33334
+ namespace $429 {
33335
+ namespace Content {
33336
+ interface ApplicationJson {
33337
+ [k: string]: unknown;
33338
+ }
33339
+ }
33340
+ }
33341
+ namespace Default {
33342
+ namespace Content {
33343
+ interface ApplicationJson {
33344
+ [k: string]: unknown;
33345
+ }
33346
+ }
33347
+ }
33348
+ }
33349
+ }
33350
+ namespace Put {
33351
+ namespace Parameters {
33352
+ type Path = {
33353
+ userId: string;
33354
+ };
33355
+ interface RequestBody {
33356
+ settingsString: string;
33357
+ }
33358
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
33359
+ type Query = {};
33360
+ }
33361
+ namespace Responses {
33362
+ namespace $204 {
33363
+ namespace Content {
33364
+ type Empty = unknown;
33365
+ }
33366
+ }
33367
+ namespace $400 {
33368
+ namespace Content {
33369
+ interface ApplicationJson {
33370
+ [k: string]: unknown;
33371
+ }
33372
+ }
33373
+ }
33374
+ namespace $429 {
33375
+ namespace Content {
33376
+ interface ApplicationJson {
33377
+ [k: string]: unknown;
33378
+ }
33379
+ }
33380
+ }
33381
+ namespace Default {
33382
+ namespace Content {
33383
+ interface ApplicationJson {
33384
+ [k: string]: unknown;
33385
+ }
33386
+ }
33387
+ }
33388
+ }
33389
+ }
33390
+ }
33391
+ namespace V2PollSettingsUserId {
33392
+ namespace Get {
34176
33393
  namespace Parameters {
34177
33394
  type Path = {
34178
- sshKeyId: string;
33395
+ userId: string;
34179
33396
  };
34180
- interface RequestBody {
34181
- comment: string;
34182
- expiresAt?: string | Date;
34183
- }
34184
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
33397
+ type Header = {};
34185
33398
  type Query = {};
34186
33399
  }
34187
33400
  namespace Responses {
34188
- namespace $204 {
33401
+ namespace $200 {
34189
33402
  namespace Content {
34190
- type Empty = unknown;
33403
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.PollUserPollSettings;
34191
33404
  }
34192
33405
  }
34193
- namespace $400 {
33406
+ namespace $429 {
34194
33407
  namespace Content {
34195
33408
  interface ApplicationJson {
34196
33409
  [k: string]: unknown;
34197
33410
  }
34198
33411
  }
34199
33412
  }
34200
- namespace $429 {
33413
+ namespace $500 {
34201
33414
  namespace Content {
34202
33415
  interface ApplicationJson {
34203
33416
  [k: string]: unknown;
@@ -34213,193 +33426,31 @@ export declare namespace MittwaldAPIV2 {
34213
33426
  }
34214
33427
  }
34215
33428
  }
34216
- namespace Delete {
33429
+ namespace Post {
34217
33430
  namespace Parameters {
34218
33431
  type Path = {
34219
- sshKeyId: string;
33432
+ userId: string;
34220
33433
  };
34221
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
34222
- type Query = {};
34223
- }
34224
- namespace Responses {
34225
- namespace $204 {
34226
- namespace Content {
34227
- type Empty = unknown;
34228
- }
34229
- }
34230
- namespace $429 {
34231
- namespace Content {
34232
- interface ApplicationJson {
34233
- [k: string]: unknown;
34234
- }
34235
- }
34236
- }
34237
- namespace Default {
34238
- namespace Content {
34239
- interface ApplicationJson {
34240
- [k: string]: unknown;
34241
- }
34242
- }
34243
- }
34244
- }
34245
- }
34246
- }
34247
- namespace V2UsersSelf {
34248
- namespace Delete {
34249
- namespace Parameters {
34250
- type Path = {};
34251
33434
  interface RequestBody {
34252
- /**
34253
- * A TOTP code or recovery code.
34254
- */
34255
- multiFactorCode?: string;
34256
- passkeyCredential?: MittwaldAPIV2.Components.Schemas.SignupPasskeyCredential;
34257
- /**
34258
- * The password of the user.
34259
- */
34260
- password: string;
33435
+ status: "completed" | "muted" | "ignored";
33436
+ userId: string;
34261
33437
  }
34262
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
33438
+ type Header = {};
34263
33439
  type Query = {};
34264
33440
  }
34265
33441
  namespace Responses {
34266
33442
  namespace $200 {
34267
33443
  namespace Content {
34268
- type Empty = unknown;
34269
- }
34270
- }
34271
- namespace $202 {
34272
- namespace Content {
34273
- interface ApplicationJson {
34274
- [k: string]: unknown;
34275
- }
33444
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.PollUserPollSettings;
34276
33445
  }
34277
33446
  }
34278
33447
  namespace $400 {
34279
- namespace Content {
34280
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsValidationErrors;
34281
- }
34282
- }
34283
- namespace $412 {
34284
- namespace Content {
34285
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsError;
34286
- }
34287
- }
34288
- namespace $429 {
34289
- namespace Content {
34290
- interface ApplicationJson {
34291
- [k: string]: unknown;
34292
- }
34293
- }
34294
- }
34295
- namespace Default {
34296
- namespace Content {
34297
- interface ApplicationJson {
34298
- [k: string]: unknown;
34299
- }
34300
- }
34301
- }
34302
- }
34303
- }
34304
- }
34305
- namespace V2UsersSelfSessionsCurrentStatus {
34306
- namespace Get {
34307
- namespace Parameters {
34308
- type Path = {};
34309
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
34310
- type Query = {};
34311
- }
34312
- namespace Responses {
34313
- namespace $200 {
34314
- namespace Content {
34315
- interface ApplicationJson {
34316
- /**
34317
- * Whether the executing user is an employee.
34318
- */
34319
- isEmployee: boolean;
34320
- /**
34321
- * Whether the current session is an impersonation.
34322
- */
34323
- isImpersonated: boolean;
34324
- /**
34325
- * The ID of the token currently in use.
34326
- */
34327
- tokenId: string;
34328
- /**
34329
- * ID of the executing user.
34330
- */
34331
- userId: string;
34332
- }
34333
- }
34334
- }
34335
- namespace $429 {
34336
- namespace Content {
34337
- interface ApplicationJson {
34338
- [k: string]: unknown;
34339
- }
34340
- }
34341
- }
34342
- namespace Default {
34343
- namespace Content {
34344
- interface ApplicationJson {
34345
- [k: string]: unknown;
34346
- }
34347
- }
34348
- }
34349
- }
34350
- }
34351
- }
34352
- namespace V2UsersSelfCredentialsPasswordUpdatedAt {
34353
- namespace Get {
34354
- namespace Parameters {
34355
- type Path = {};
34356
- interface RequestBody {
34357
- }
34358
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
34359
- type Query = {};
34360
- }
34361
- namespace Responses {
34362
- namespace $200 {
34363
- namespace Content {
34364
- interface ApplicationJson {
34365
- passwordUpdatedAt: string;
34366
- }
34367
- }
34368
- }
34369
- namespace $429 {
34370
- namespace Content {
34371
- interface ApplicationJson {
34372
- [k: string]: unknown;
34373
- }
34374
- }
34375
- }
34376
- namespace Default {
34377
33448
  namespace Content {
34378
33449
  interface ApplicationJson {
34379
33450
  [k: string]: unknown;
34380
33451
  }
34381
33452
  }
34382
33453
  }
34383
- }
34384
- }
34385
- }
34386
- namespace V2UsersUserIdSettings {
34387
- namespace Get {
34388
- namespace Parameters {
34389
- type Path = {
34390
- userId: string;
34391
- };
34392
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
34393
- type Query = {};
34394
- }
34395
- namespace Responses {
34396
- namespace $200 {
34397
- namespace Content {
34398
- interface ApplicationJson {
34399
- settingsString?: string;
34400
- }
34401
- }
34402
- }
34403
33454
  namespace $429 {
34404
33455
  namespace Content {
34405
33456
  interface ApplicationJson {
@@ -34407,40 +33458,7 @@ export declare namespace MittwaldAPIV2 {
34407
33458
  }
34408
33459
  }
34409
33460
  }
34410
- namespace Default {
34411
- namespace Content {
34412
- interface ApplicationJson {
34413
- [k: string]: unknown;
34414
- }
34415
- }
34416
- }
34417
- }
34418
- }
34419
- namespace Put {
34420
- namespace Parameters {
34421
- type Path = {
34422
- userId: string;
34423
- };
34424
- interface RequestBody {
34425
- settingsString: string;
34426
- }
34427
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
34428
- type Query = {};
34429
- }
34430
- namespace Responses {
34431
- namespace $204 {
34432
- namespace Content {
34433
- type Empty = unknown;
34434
- }
34435
- }
34436
- namespace $400 {
34437
- namespace Content {
34438
- interface ApplicationJson {
34439
- [k: string]: unknown;
34440
- }
34441
- }
34442
- }
34443
- namespace $429 {
33461
+ namespace $500 {
34444
33462
  namespace Content {
34445
33463
  interface ApplicationJson {
34446
33464
  [k: string]: unknown;
@@ -35748,60 +34766,36 @@ export declare namespace MittwaldAPIV2 {
35748
34766
  }
35749
34767
  }
35750
34768
  }
35751
- namespace V2PollSettingsUserId {
35752
- namespace Get {
35753
- namespace Parameters {
35754
- type Path = {
35755
- userId: string;
35756
- };
35757
- type Header = {};
35758
- type Query = {};
35759
- }
35760
- namespace Responses {
35761
- namespace $200 {
35762
- namespace Content {
35763
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.PollUserPollSettings;
35764
- }
35765
- }
35766
- namespace $429 {
35767
- namespace Content {
35768
- interface ApplicationJson {
35769
- [k: string]: unknown;
35770
- }
35771
- }
35772
- }
35773
- namespace $500 {
35774
- namespace Content {
35775
- interface ApplicationJson {
35776
- [k: string]: unknown;
35777
- }
35778
- }
35779
- }
35780
- namespace Default {
35781
- namespace Content {
35782
- interface ApplicationJson {
35783
- [k: string]: unknown;
35784
- }
35785
- }
35786
- }
35787
- }
35788
- }
34769
+ namespace V2Authinfo2CheckDomain {
35789
34770
  namespace Post {
35790
34771
  namespace Parameters {
35791
- type Path = {
35792
- userId: string;
35793
- };
34772
+ type Path = {};
35794
34773
  interface RequestBody {
35795
- status: "completed" | "muted" | "ignored";
35796
- userId: string;
34774
+ domain: string;
35797
34775
  }
35798
- type Header = {};
34776
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
35799
34777
  type Query = {};
35800
34778
  }
35801
34779
  namespace Responses {
35802
34780
  namespace $200 {
35803
34781
  namespace Content {
35804
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.PollUserPollSettings;
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
+ }
35805
34799
  }
35806
34800
  }
35807
34801
  namespace $400 {
@@ -35818,7 +34812,7 @@ export declare namespace MittwaldAPIV2 {
35818
34812
  }
35819
34813
  }
35820
34814
  }
35821
- namespace $500 {
34815
+ namespace $503 {
35822
34816
  namespace Content {
35823
34817
  interface ApplicationJson {
35824
34818
  [k: string]: unknown;