@mittwald/api-client 4.511.0 → 4.512.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.
@@ -1970,6 +1970,38 @@ export declare namespace MittwaldAPIV2 {
1970
1970
  type RequestData = InferredRequestData<typeof descriptors.verificationVerifyCompany>;
1971
1971
  type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.verificationVerifyCompany, TStatus>;
1972
1972
  }
1973
+ namespace UserAuthenticatePasskey {
1974
+ type RequestData = InferredRequestData<typeof descriptors.userAuthenticatePasskey>;
1975
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userAuthenticatePasskey, TStatus>;
1976
+ }
1977
+ namespace UserCreatePasskeyChallenge {
1978
+ type RequestData = InferredRequestData<typeof descriptors.userCreatePasskeyChallenge>;
1979
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userCreatePasskeyChallenge, TStatus>;
1980
+ }
1981
+ namespace UserDeletePasskey {
1982
+ type RequestData = InferredRequestData<typeof descriptors.userDeletePasskey>;
1983
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userDeletePasskey, TStatus>;
1984
+ }
1985
+ namespace UserUpdatePasskey {
1986
+ type RequestData = InferredRequestData<typeof descriptors.userUpdatePasskey>;
1987
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userUpdatePasskey, TStatus>;
1988
+ }
1989
+ namespace UserListPasskeys {
1990
+ type RequestData = InferredRequestData<typeof descriptors.userListPasskeys>;
1991
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userListPasskeys, TStatus>;
1992
+ }
1993
+ namespace UserCreatePasskey {
1994
+ type RequestData = InferredRequestData<typeof descriptors.userCreatePasskey>;
1995
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userCreatePasskey, TStatus>;
1996
+ }
1997
+ namespace UserCreatePasskeyConfirmationChallenge {
1998
+ type RequestData = InferredRequestData<typeof descriptors.userCreatePasskeyConfirmationChallenge>;
1999
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userCreatePasskeyConfirmationChallenge, TStatus>;
2000
+ }
2001
+ namespace UserCreatePasskeyRegistrationChallenge {
2002
+ type RequestData = InferredRequestData<typeof descriptors.userCreatePasskeyRegistrationChallenge>;
2003
+ type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.userCreatePasskeyRegistrationChallenge, TStatus>;
2004
+ }
1973
2005
  }
1974
2006
  namespace Components {
1975
2007
  namespace Schemas {
@@ -8859,6 +8891,314 @@ export declare namespace MittwaldAPIV2 {
8859
8891
  }
8860
8892
  type VerificationEmailOrigin = "IS_MITTWALD" | "IS_NOT_MITTWALD" | "COULD_BE_MITTWALD";
8861
8893
  type ContainerVolumeSortOrder = "nameAsc" | "nameDesc" | "storageAsc" | "storageDesc";
8894
+ /**
8895
+ * A challenge for signing in or confirming an action with a passkey. Run `navigator.credentials.get()` with
8896
+ * `options` and send `challengeId` together with the resulting `credential.toJSON()`. The challenge can be used
8897
+ * once.
8898
+ *
8899
+ */
8900
+ interface SignupPasskeyChallenge {
8901
+ challengeId: string;
8902
+ options: MittwaldAPIV2.Components.Schemas.SignupPasskeyRequestOptions;
8903
+ }
8904
+ /**
8905
+ * A passkey assertion: the result of `navigator.credentials.get()` serialized with
8906
+ * [`credential.toJSON()`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredential-tojson), as WebAuthn Level 3
8907
+ * [`AuthenticationResponseJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-authenticationresponsejson). Send it
8908
+ * unchanged. Binary values are base64url-encoded without padding.
8909
+ *
8910
+ */
8911
+ interface SignupPasskeyAuthenticationResponse {
8912
+ /**
8913
+ * `platform` or `cross-platform`, if the browser reports it.
8914
+ */
8915
+ authenticatorAttachment?: string;
8916
+ /**
8917
+ * WebAuthn Level 3
8918
+ * [`AuthenticationExtensionsClientOutputsJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-authenticationextensionsclientoutputsjson).
8919
+ *
8920
+ */
8921
+ clientExtensionResults: {};
8922
+ /**
8923
+ * The credential id, base64url-encoded without padding.
8924
+ */
8925
+ id: string;
8926
+ /**
8927
+ * The credential id, base64url-encoded without padding (same value as `id`).
8928
+ */
8929
+ rawId: string;
8930
+ /**
8931
+ * WebAuthn Level 3
8932
+ * [`AuthenticatorAssertionResponseJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-authenticatorassertionresponsejson).
8933
+ *
8934
+ */
8935
+ response: {
8936
+ /**
8937
+ * The authenticator data, base64url-encoded without padding.
8938
+ */
8939
+ authenticatorData: string;
8940
+ /**
8941
+ * The client data (type, challenge, origin) as JSON, base64url-encoded without padding.
8942
+ */
8943
+ clientDataJSON: string;
8944
+ /**
8945
+ * The assertion signature, base64url-encoded without padding.
8946
+ */
8947
+ signature: string;
8948
+ /**
8949
+ * The `user.id` of the registration, base64url-encoded without padding. The passkey login
8950
+ * (`POST /authenticate-passkey`) takes the user from it.
8951
+ *
8952
+ */
8953
+ userHandle?: string;
8954
+ };
8955
+ /**
8956
+ * The credential type, always `public-key`.
8957
+ */
8958
+ type: string;
8959
+ }
8960
+ /**
8961
+ * Options for registering a passkey, as WebAuthn Level 3
8962
+ * [`PublicKeyCredentialCreationOptionsJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-publickeycredentialcreationoptionsjson).
8963
+ * Pass the object unchanged to
8964
+ * [`PublicKeyCredential.parseCreationOptionsFromJSON()`](https://www.w3.org/TR/webauthn-3/#sctn-parseCreationOptionsFromJSON)
8965
+ * and the result as `publicKey` to `navigator.credentials.create()`. Send the resulting credential back as
8966
+ * [`credential.toJSON()`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredential-tojson) together with the
8967
+ * `challengeId` the options came with. Binary values are base64url-encoded without padding.
8968
+ *
8969
+ */
8970
+ interface SignupPasskeyCreationOptions {
8971
+ /**
8972
+ * Always `none`; the API does not check which authenticator model created the passkey.
8973
+ */
8974
+ attestation: string;
8975
+ /**
8976
+ * Not set by this API.
8977
+ */
8978
+ attestationFormats?: string[];
8979
+ /**
8980
+ * Always a discoverable credential (`residentKey: required`) with user verification
8981
+ * (`userVerification: required`); no `authenticatorAttachment`, so the browser also offers other devices
8982
+ * (QR code).
8983
+ *
8984
+ */
8985
+ authenticatorSelection: {
8986
+ authenticatorAttachment?: string;
8987
+ requireResidentKey?: boolean;
8988
+ residentKey?: string;
8989
+ userVerification?: string;
8990
+ };
8991
+ /**
8992
+ * 32 random bytes, base64url-encoded without padding. Can be used once.
8993
+ */
8994
+ challenge: string;
8995
+ /**
8996
+ * The passkeys the user already has for this relying party; the authenticator does not register them again.
8997
+ */
8998
+ excludeCredentials: MittwaldAPIV2.Components.Schemas.SignupPasskeyCredentialDescriptor[];
8999
+ /**
9000
+ * WebAuthn Level 3
9001
+ * [`AuthenticationExtensionsClientInputsJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-authenticationextensionsclientinputsjson).
9002
+ *
9003
+ */
9004
+ extensions?: {};
9005
+ /**
9006
+ * Hints for the browser which authenticator to offer. Not set by this API.
9007
+ */
9008
+ hints?: string[];
9009
+ /**
9010
+ * The accepted key types, ES256 (`-7`) and RS256 (`-257`).
9011
+ */
9012
+ pubKeyCredParams: {
9013
+ /**
9014
+ * A COSE algorithm identifier.
9015
+ */
9016
+ alg: number;
9017
+ /**
9018
+ * Always `public-key`.
9019
+ */
9020
+ type: string;
9021
+ }[];
9022
+ /**
9023
+ * The relying party, selected from the `Origin` header of the request that created the challenge.
9024
+ */
9025
+ rp: {
9026
+ id: string;
9027
+ name: string;
9028
+ };
9029
+ /**
9030
+ * Milliseconds until the challenge expires.
9031
+ */
9032
+ timeout: number;
9033
+ /**
9034
+ * The user the passkey is created for, as WebAuthn Level 3
9035
+ * [`PublicKeyCredentialUserEntityJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-publickeycredentialuserentityjson).
9036
+ *
9037
+ */
9038
+ user: {
9039
+ /**
9040
+ * First and last name of the user, or the email address if both are empty.
9041
+ */
9042
+ displayName: string;
9043
+ /**
9044
+ * The UTF-8 bytes of the user id, base64url-encoded without padding. A passkey login returns it as
9045
+ * `response.userHandle`.
9046
+ *
9047
+ */
9048
+ id: string;
9049
+ /**
9050
+ * The verified email address of the user.
9051
+ */
9052
+ name: string;
9053
+ };
9054
+ }
9055
+ /**
9056
+ * A passkey of the user, as WebAuthn Level 3
9057
+ * [`PublicKeyCredentialDescriptorJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-publickeycredentialdescriptorjson).
9058
+ *
9059
+ */
9060
+ interface SignupPasskeyCredentialDescriptor {
9061
+ /**
9062
+ * The credential id, base64url-encoded without padding.
9063
+ */
9064
+ id: string;
9065
+ /**
9066
+ * How the browser can reach the authenticator, as reported at registration (`internal`, `hybrid`, `usb`,
9067
+ * `nfc`, `ble`, `smart-card`).
9068
+ *
9069
+ */
9070
+ transports?: string[];
9071
+ /**
9072
+ * The credential type, always `public-key`.
9073
+ */
9074
+ type: string;
9075
+ }
9076
+ /**
9077
+ * A passkey assertion that proves the second factor. `challengeId` comes from `POST /users/self/passkey-challenges`
9078
+ * (or from `passkeyChallenge` of `POST /authenticate` for `POST /authenticate-mfa`), `credential` is the
9079
+ * `credential.toJSON()` of the `navigator.credentials.get()` call with its `options`.
9080
+ *
9081
+ */
9082
+ interface SignupPasskeyCredential {
9083
+ challengeId: string;
9084
+ credential: MittwaldAPIV2.Components.Schemas.SignupPasskeyAuthenticationResponse;
9085
+ }
9086
+ /**
9087
+ * A challenge for registering a passkey. Run `navigator.credentials.create()` with `options` and send
9088
+ * `challengeId` together with the resulting `credential.toJSON()` to `POST /users/self/passkeys`. The challenge
9089
+ * can be used once.
9090
+ *
9091
+ */
9092
+ interface SignupPasskeyRegistrationChallenge {
9093
+ challengeId: string;
9094
+ options: MittwaldAPIV2.Components.Schemas.SignupPasskeyCreationOptions;
9095
+ }
9096
+ /**
9097
+ * A new passkey: the result of `navigator.credentials.create()` serialized with
9098
+ * [`credential.toJSON()`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredential-tojson), as WebAuthn Level 3
9099
+ * [`RegistrationResponseJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-registrationresponsejson). Send it
9100
+ * unchanged. Binary values are base64url-encoded without padding.
9101
+ *
9102
+ */
9103
+ interface SignupPasskeyRegistrationResponse {
9104
+ /**
9105
+ * `platform` or `cross-platform`, if the browser reports it.
9106
+ */
9107
+ authenticatorAttachment?: string;
9108
+ /**
9109
+ * WebAuthn Level 3
9110
+ * [`AuthenticationExtensionsClientOutputsJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-authenticationextensionsclientoutputsjson).
9111
+ *
9112
+ */
9113
+ clientExtensionResults: {};
9114
+ /**
9115
+ * The credential id, base64url-encoded without padding.
9116
+ */
9117
+ id: string;
9118
+ /**
9119
+ * The credential id, base64url-encoded without padding (same value as `id`).
9120
+ */
9121
+ rawId: string;
9122
+ /**
9123
+ * WebAuthn Level 3
9124
+ * [`AuthenticatorAttestationResponseJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-authenticatorattestationresponsejson).
9125
+ *
9126
+ */
9127
+ response: {
9128
+ /**
9129
+ * The CBOR attestation object, base64url-encoded without padding.
9130
+ */
9131
+ attestationObject: string;
9132
+ /**
9133
+ * The authenticator data, base64url-encoded without padding.
9134
+ */
9135
+ authenticatorData: string;
9136
+ /**
9137
+ * The client data (type, challenge, origin) as JSON, base64url-encoded without padding.
9138
+ */
9139
+ clientDataJSON: string;
9140
+ /**
9141
+ * The public key as DER `SubjectPublicKeyInfo`, base64url-encoded without padding, if the browser knows the algorithm.
9142
+ */
9143
+ publicKey?: string;
9144
+ /**
9145
+ * The COSE algorithm identifier of the key.
9146
+ */
9147
+ publicKeyAlgorithm: number;
9148
+ /**
9149
+ * How the browser can reach the authenticator (`internal`, `hybrid`, `usb`, `nfc`, `ble`, `smart-card`).
9150
+ */
9151
+ transports: string[];
9152
+ };
9153
+ /**
9154
+ * The credential type, always `public-key`.
9155
+ */
9156
+ type: string;
9157
+ }
9158
+ /**
9159
+ * Options for signing in with a passkey, as WebAuthn Level 3
9160
+ * [`PublicKeyCredentialRequestOptionsJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-publickeycredentialrequestoptionsjson).
9161
+ * Pass the object unchanged to
9162
+ * [`PublicKeyCredential.parseRequestOptionsFromJSON()`](https://www.w3.org/TR/webauthn-3/#sctn-parseRequestOptionsFromJSON)
9163
+ * and the result as `publicKey` to `navigator.credentials.get()`. Send the resulting credential back as
9164
+ * [`credential.toJSON()`](https://www.w3.org/TR/webauthn-3/#dom-publickeycredential-tojson) together with the
9165
+ * `challengeId` the options came with. Binary values are base64url-encoded without padding.
9166
+ *
9167
+ */
9168
+ interface SignupPasskeyRequestOptions {
9169
+ /**
9170
+ * The passkeys of the user for this relying party. Empty for the passkey login, so the browser offers every
9171
+ * passkey it has for the relying party.
9172
+ *
9173
+ */
9174
+ allowCredentials: MittwaldAPIV2.Components.Schemas.SignupPasskeyCredentialDescriptor[];
9175
+ /**
9176
+ * 32 random bytes, base64url-encoded without padding. Can be used once.
9177
+ */
9178
+ challenge: string;
9179
+ /**
9180
+ * WebAuthn Level 3
9181
+ * [`AuthenticationExtensionsClientInputsJSON`](https://www.w3.org/TR/webauthn-3/#dictdef-authenticationextensionsclientinputsjson).
9182
+ *
9183
+ */
9184
+ extensions?: {};
9185
+ /**
9186
+ * Hints for the browser which authenticator to offer. Not set by this API.
9187
+ */
9188
+ hints?: string[];
9189
+ /**
9190
+ * The relying party, selected from the `Origin` header of the request that created the challenge.
9191
+ */
9192
+ rpId: string;
9193
+ /**
9194
+ * Milliseconds until the challenge expires.
9195
+ */
9196
+ timeout: number;
9197
+ /**
9198
+ * Always `required`; the authenticator has to verify the user (biometrics or device PIN).
9199
+ */
9200
+ userVerification: string;
9201
+ }
8862
9202
  interface CommonsAddress {
8863
9203
  street: string;
8864
9204
  houseNumber: string;
@@ -10893,6 +11233,13 @@ export declare namespace MittwaldAPIV2 {
10893
11233
  type ApplicationJson = MittwaldAPIV2.Components.Schemas.AppAppInstallation;
10894
11234
  }
10895
11235
  }
11236
+ namespace $403 {
11237
+ namespace Content {
11238
+ interface ApplicationJson {
11239
+ [k: string]: unknown;
11240
+ }
11241
+ }
11242
+ }
10896
11243
  namespace $404 {
10897
11244
  namespace Content {
10898
11245
  interface ApplicationJson {
@@ -10967,6 +11314,10 @@ export declare namespace MittwaldAPIV2 {
10967
11314
  };
10968
11315
  interface RequestBody {
10969
11316
  appVersionId?: string;
11317
+ /**
11318
+ * Enabling automatic updates may first update the AppInstallation to the newest permitted app version.
11319
+ */
11320
+ autoUpdatesActivated?: boolean;
10970
11321
  customDocumentRoot?: string;
10971
11322
  /**
10972
11323
  * Desired changes to the databases linked to this AppInstallation, keyed by
@@ -19401,6 +19752,13 @@ export declare namespace MittwaldAPIV2 {
19401
19752
  }
19402
19753
  }
19403
19754
  }
19755
+ namespace $403 {
19756
+ namespace Content {
19757
+ interface ApplicationJson {
19758
+ [k: string]: unknown;
19759
+ }
19760
+ }
19761
+ }
19404
19762
  namespace $404 {
19405
19763
  namespace Content {
19406
19764
  interface ApplicationJson {
@@ -19709,6 +20067,13 @@ export declare namespace MittwaldAPIV2 {
19709
20067
  }
19710
20068
  }
19711
20069
  }
20070
+ namespace $403 {
20071
+ namespace Content {
20072
+ interface ApplicationJson {
20073
+ [k: string]: unknown;
20074
+ }
20075
+ }
20076
+ }
19712
20077
  namespace $404 {
19713
20078
  namespace Content {
19714
20079
  interface ApplicationJson {
@@ -32177,7 +32542,8 @@ export declare namespace MittwaldAPIV2 {
32177
32542
  /**
32178
32543
  * The second factor - otp code or recovery code.
32179
32544
  */
32180
- multiFactorCode: string;
32545
+ multiFactorCode?: string;
32546
+ passkeyCredential?: MittwaldAPIV2.Components.Schemas.SignupPasskeyCredential;
32181
32547
  /**
32182
32548
  * The password of the user.
32183
32549
  */
@@ -32283,7 +32649,12 @@ export declare namespace MittwaldAPIV2 {
32283
32649
  namespace $202 {
32284
32650
  namespace Content {
32285
32651
  interface ApplicationJson {
32652
+ /**
32653
+ * More values may be added in the future; clients must ignore values they do not know.
32654
+ */
32655
+ availableSecondFactors: ("totp" | "passkey")[];
32286
32656
  name?: "SecondFactorRequired";
32657
+ passkeyChallenge?: MittwaldAPIV2.Components.Schemas.SignupPasskeyChallenge;
32287
32658
  }
32288
32659
  }
32289
32660
  }
@@ -32458,9 +32829,7 @@ export declare namespace MittwaldAPIV2 {
32458
32829
  type Path = {};
32459
32830
  interface RequestBody {
32460
32831
  /**
32461
- * Multi Factor Code to confirm MFA.
32462
- * This is optional, depending on the MFA activation status of the profile.
32463
- *
32832
+ * A TOTP code or recovery code.
32464
32833
  */
32465
32834
  multiFactorCode?: string;
32466
32835
  /**
@@ -32471,6 +32840,7 @@ export declare namespace MittwaldAPIV2 {
32471
32840
  * The old password.
32472
32841
  */
32473
32842
  oldPassword: string;
32843
+ passkeyCredential?: MittwaldAPIV2.Components.Schemas.SignupPasskeyCredential;
32474
32844
  }
32475
32845
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
32476
32846
  type Query = {};
@@ -32535,7 +32905,13 @@ export declare namespace MittwaldAPIV2 {
32535
32905
  namespace $200 {
32536
32906
  namespace Content {
32537
32907
  interface ApplicationJson {
32908
+ /**
32909
+ * TOTP has been confirmed and is active.
32910
+ */
32538
32911
  confirmed: boolean;
32912
+ /**
32913
+ * TOTP has been initialized.
32914
+ */
32539
32915
  initialized: boolean;
32540
32916
  }
32541
32917
  }
@@ -32561,73 +32937,74 @@ export declare namespace MittwaldAPIV2 {
32561
32937
  type Path = {};
32562
32938
  interface RequestBody {
32563
32939
  /**
32564
- * Multi Factor Code to authorize your request.
32565
- */
32566
- multiFactorCode: string;
32567
- }
32568
- type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
32569
- type Query = {};
32570
- }
32571
- namespace Responses {
32572
- namespace $200 {
32573
- namespace Content {
32574
- interface ApplicationJson {
32575
- /**
32576
- * @minItems 20
32577
- * @maxItems 20
32578
- */
32579
- recoveryCodesList: [
32580
- string,
32581
- string,
32582
- string,
32583
- string,
32584
- string,
32585
- string,
32586
- string,
32587
- string,
32588
- string,
32589
- string,
32590
- string,
32591
- string,
32592
- string,
32593
- string,
32594
- string,
32595
- string,
32596
- string,
32597
- string,
32598
- string,
32599
- string
32600
- ];
32601
- }
32602
- }
32603
- }
32604
- namespace $400 {
32605
- namespace Content {
32606
- type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsValidationErrors;
32607
- }
32608
- }
32609
- namespace $429 {
32610
- namespace Content {
32611
- interface ApplicationJson {
32612
- [k: string]: unknown;
32613
- }
32614
- }
32615
- }
32616
- namespace Default {
32617
- namespace Content {
32618
- interface ApplicationJson {
32619
- [k: string]: unknown;
32620
- }
32621
- }
32622
- }
32623
- }
32624
- }
32625
- namespace Post {
32626
- namespace Parameters {
32627
- type Path = {};
32628
- interface RequestBody {
32629
- /**
32630
- * Multi Factor Code to confirm MFA.
32940
+ * A TOTP code or recovery code.
32941
+ */
32942
+ multiFactorCode?: string;
32943
+ passkeyCredential?: MittwaldAPIV2.Components.Schemas.SignupPasskeyCredential;
32944
+ }
32945
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
32946
+ type Query = {};
32947
+ }
32948
+ namespace Responses {
32949
+ namespace $200 {
32950
+ namespace Content {
32951
+ interface ApplicationJson {
32952
+ /**
32953
+ * @minItems 20
32954
+ * @maxItems 20
32955
+ */
32956
+ recoveryCodesList: [
32957
+ string,
32958
+ string,
32959
+ string,
32960
+ string,
32961
+ string,
32962
+ string,
32963
+ string,
32964
+ string,
32965
+ string,
32966
+ string,
32967
+ string,
32968
+ string,
32969
+ string,
32970
+ string,
32971
+ string,
32972
+ string,
32973
+ string,
32974
+ string,
32975
+ string,
32976
+ string
32977
+ ];
32978
+ }
32979
+ }
32980
+ }
32981
+ namespace $400 {
32982
+ namespace Content {
32983
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsValidationErrors;
32984
+ }
32985
+ }
32986
+ namespace $429 {
32987
+ namespace Content {
32988
+ interface ApplicationJson {
32989
+ [k: string]: unknown;
32990
+ }
32991
+ }
32992
+ }
32993
+ namespace Default {
32994
+ namespace Content {
32995
+ interface ApplicationJson {
32996
+ [k: string]: unknown;
32997
+ }
32998
+ }
32999
+ }
33000
+ }
33001
+ }
33002
+ namespace Post {
33003
+ namespace Parameters {
33004
+ type Path = {};
33005
+ interface RequestBody {
33006
+ /**
33007
+ * Multi Factor Code to confirm MFA.
32631
33008
  */
32632
33009
  multiFactorCode: string;
32633
33010
  }
@@ -32693,9 +33070,10 @@ export declare namespace MittwaldAPIV2 {
32693
33070
  type Path = {};
32694
33071
  interface RequestBody {
32695
33072
  /**
32696
- * Multi Factor Code to confirm MFA.
33073
+ * A TOTP code or recovery code.
32697
33074
  */
32698
- multiFactorCode: string;
33075
+ multiFactorCode?: string;
33076
+ passkeyCredential?: MittwaldAPIV2.Components.Schemas.SignupPasskeyCredential;
32699
33077
  }
32700
33078
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
32701
33079
  type Query = {};
@@ -33241,9 +33619,13 @@ export declare namespace MittwaldAPIV2 {
33241
33619
  type Path = {};
33242
33620
  interface RequestBody {
33243
33621
  /**
33244
- * Multi Factor Code to authorize your request.
33622
+ * A TOTP code or recovery code.
33245
33623
  */
33246
33624
  multiFactorCode?: string;
33625
+ passkeyCredential?: MittwaldAPIV2.Components.Schemas.SignupPasskeyCredential;
33626
+ /**
33627
+ * The password of the user.
33628
+ */
33247
33629
  password: string;
33248
33630
  }
33249
33631
  type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
@@ -33269,9 +33651,7 @@ export declare namespace MittwaldAPIV2 {
33269
33651
  }
33270
33652
  namespace $412 {
33271
33653
  namespace Content {
33272
- interface ApplicationJson {
33273
- [k: string]: unknown;
33274
- }
33654
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsError;
33275
33655
  }
33276
33656
  }
33277
33657
  namespace $429 {
@@ -34803,5 +35183,445 @@ export declare namespace MittwaldAPIV2 {
34803
35183
  }
34804
35184
  }
34805
35185
  }
35186
+ namespace V2AuthenticatePasskey {
35187
+ namespace Post {
35188
+ namespace Parameters {
35189
+ type Path = {};
35190
+ interface RequestBody {
35191
+ challengeId: string;
35192
+ credential: MittwaldAPIV2.Components.Schemas.SignupPasskeyAuthenticationResponse;
35193
+ }
35194
+ type Header = {};
35195
+ type Query = {
35196
+ cookieOnly?: boolean;
35197
+ };
35198
+ }
35199
+ namespace Responses {
35200
+ namespace $200 {
35201
+ namespace Content {
35202
+ interface ApplicationJson {
35203
+ /**
35204
+ * The expiration date of the token.
35205
+ */
35206
+ expires: string;
35207
+ /**
35208
+ * Refresh token to refresh your access token even after it has expired.
35209
+ */
35210
+ refreshToken: string;
35211
+ /**
35212
+ * Public token to identify yourself against the api gateway.
35213
+ */
35214
+ token: string;
35215
+ }
35216
+ }
35217
+ }
35218
+ namespace $204 {
35219
+ namespace Content {
35220
+ type Empty = unknown;
35221
+ }
35222
+ }
35223
+ namespace $400 {
35224
+ namespace Content {
35225
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsValidationErrors | MittwaldAPIV2.Components.Schemas.CommonsError;
35226
+ }
35227
+ }
35228
+ namespace $429 {
35229
+ namespace Content {
35230
+ interface ApplicationJson {
35231
+ [k: string]: unknown;
35232
+ }
35233
+ }
35234
+ }
35235
+ namespace $500 {
35236
+ namespace Content {
35237
+ interface ApplicationJson {
35238
+ [k: string]: unknown;
35239
+ }
35240
+ }
35241
+ }
35242
+ namespace Default {
35243
+ namespace Content {
35244
+ interface ApplicationJson {
35245
+ [k: string]: unknown;
35246
+ }
35247
+ }
35248
+ }
35249
+ }
35250
+ }
35251
+ }
35252
+ namespace V2PasskeyChallenges {
35253
+ namespace Post {
35254
+ namespace Parameters {
35255
+ type Path = {};
35256
+ type Header = {};
35257
+ type Query = {};
35258
+ }
35259
+ namespace Responses {
35260
+ namespace $201 {
35261
+ namespace Content {
35262
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.SignupPasskeyChallenge;
35263
+ }
35264
+ }
35265
+ namespace $400 {
35266
+ namespace Content {
35267
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsError;
35268
+ }
35269
+ }
35270
+ namespace $429 {
35271
+ namespace Content {
35272
+ interface ApplicationJson {
35273
+ [k: string]: unknown;
35274
+ }
35275
+ }
35276
+ }
35277
+ namespace $500 {
35278
+ namespace Content {
35279
+ interface ApplicationJson {
35280
+ [k: string]: unknown;
35281
+ }
35282
+ }
35283
+ }
35284
+ namespace Default {
35285
+ namespace Content {
35286
+ interface ApplicationJson {
35287
+ [k: string]: unknown;
35288
+ }
35289
+ }
35290
+ }
35291
+ }
35292
+ }
35293
+ }
35294
+ namespace V2UsersSelfPasskeysPasskeyId {
35295
+ namespace Delete {
35296
+ namespace Parameters {
35297
+ type Path = {
35298
+ passkeyId: string;
35299
+ };
35300
+ interface RequestBody {
35301
+ /**
35302
+ * A TOTP code or recovery code.
35303
+ */
35304
+ multiFactorCode?: string;
35305
+ passkeyCredential?: MittwaldAPIV2.Components.Schemas.SignupPasskeyCredential;
35306
+ }
35307
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
35308
+ type Query = {};
35309
+ }
35310
+ namespace Responses {
35311
+ namespace $204 {
35312
+ namespace Content {
35313
+ type Empty = unknown;
35314
+ }
35315
+ }
35316
+ namespace $400 {
35317
+ namespace Content {
35318
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsValidationErrors;
35319
+ }
35320
+ }
35321
+ namespace $404 {
35322
+ namespace Content {
35323
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsError;
35324
+ }
35325
+ }
35326
+ namespace $429 {
35327
+ namespace Content {
35328
+ interface ApplicationJson {
35329
+ [k: string]: unknown;
35330
+ }
35331
+ }
35332
+ }
35333
+ namespace $500 {
35334
+ namespace Content {
35335
+ interface ApplicationJson {
35336
+ [k: string]: unknown;
35337
+ }
35338
+ }
35339
+ }
35340
+ namespace Default {
35341
+ namespace Content {
35342
+ interface ApplicationJson {
35343
+ [k: string]: unknown;
35344
+ }
35345
+ }
35346
+ }
35347
+ }
35348
+ }
35349
+ namespace Patch {
35350
+ namespace Parameters {
35351
+ type Path = {
35352
+ passkeyId: string;
35353
+ };
35354
+ interface RequestBody {
35355
+ name: string;
35356
+ }
35357
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
35358
+ type Query = {};
35359
+ }
35360
+ namespace Responses {
35361
+ namespace $204 {
35362
+ namespace Content {
35363
+ type Empty = unknown;
35364
+ }
35365
+ }
35366
+ namespace $400 {
35367
+ namespace Content {
35368
+ interface ApplicationJson {
35369
+ [k: string]: unknown;
35370
+ }
35371
+ }
35372
+ }
35373
+ namespace $404 {
35374
+ namespace Content {
35375
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsError;
35376
+ }
35377
+ }
35378
+ namespace $429 {
35379
+ namespace Content {
35380
+ interface ApplicationJson {
35381
+ [k: string]: unknown;
35382
+ }
35383
+ }
35384
+ }
35385
+ namespace $500 {
35386
+ namespace Content {
35387
+ interface ApplicationJson {
35388
+ [k: string]: unknown;
35389
+ }
35390
+ }
35391
+ }
35392
+ namespace Default {
35393
+ namespace Content {
35394
+ interface ApplicationJson {
35395
+ [k: string]: unknown;
35396
+ }
35397
+ }
35398
+ }
35399
+ }
35400
+ }
35401
+ }
35402
+ namespace V2UsersSelfPasskeys {
35403
+ namespace Get {
35404
+ namespace Parameters {
35405
+ type Path = {};
35406
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
35407
+ type Query = {};
35408
+ }
35409
+ namespace Responses {
35410
+ namespace $200 {
35411
+ namespace Content {
35412
+ type ApplicationJson = {
35413
+ /**
35414
+ * The authenticator model identifier.
35415
+ */
35416
+ aaguid: string;
35417
+ /**
35418
+ * Whether the authenticator can back up (sync) the passkey, as reported at registration.
35419
+ */
35420
+ backupEligible: boolean;
35421
+ /**
35422
+ * Whether the passkey was backed up (synced) at registration. Not updated afterwards.
35423
+ */
35424
+ backupState: boolean;
35425
+ createdAt: string;
35426
+ /**
35427
+ * The base64url encoded WebAuthn credential id.
35428
+ */
35429
+ credentialId: string;
35430
+ id: string;
35431
+ name: string;
35432
+ rpId: string;
35433
+ }[];
35434
+ }
35435
+ }
35436
+ namespace $429 {
35437
+ namespace Content {
35438
+ interface ApplicationJson {
35439
+ [k: string]: unknown;
35440
+ }
35441
+ }
35442
+ }
35443
+ namespace $500 {
35444
+ namespace Content {
35445
+ interface ApplicationJson {
35446
+ [k: string]: unknown;
35447
+ }
35448
+ }
35449
+ }
35450
+ namespace Default {
35451
+ namespace Content {
35452
+ interface ApplicationJson {
35453
+ [k: string]: unknown;
35454
+ }
35455
+ }
35456
+ }
35457
+ }
35458
+ }
35459
+ namespace Post {
35460
+ namespace Parameters {
35461
+ type Path = {};
35462
+ interface RequestBody {
35463
+ challengeId: string;
35464
+ credential: MittwaldAPIV2.Components.Schemas.SignupPasskeyRegistrationResponse;
35465
+ /**
35466
+ * The display name of the passkey.
35467
+ */
35468
+ name: string;
35469
+ }
35470
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
35471
+ type Query = {};
35472
+ }
35473
+ namespace Responses {
35474
+ namespace $201 {
35475
+ namespace Content {
35476
+ interface ApplicationJson {
35477
+ id: string;
35478
+ /**
35479
+ * Only set if the passkey is the first second factor of the user.
35480
+ */
35481
+ recoveryCodes?: string[];
35482
+ }
35483
+ }
35484
+ }
35485
+ namespace $400 {
35486
+ namespace Content {
35487
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsValidationErrors | MittwaldAPIV2.Components.Schemas.CommonsError;
35488
+ }
35489
+ }
35490
+ namespace $412 {
35491
+ namespace Content {
35492
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsError;
35493
+ }
35494
+ }
35495
+ namespace $429 {
35496
+ namespace Content {
35497
+ interface ApplicationJson {
35498
+ [k: string]: unknown;
35499
+ }
35500
+ }
35501
+ }
35502
+ namespace $500 {
35503
+ namespace Content {
35504
+ interface ApplicationJson {
35505
+ [k: string]: unknown;
35506
+ }
35507
+ }
35508
+ }
35509
+ namespace Default {
35510
+ namespace Content {
35511
+ interface ApplicationJson {
35512
+ [k: string]: unknown;
35513
+ }
35514
+ }
35515
+ }
35516
+ }
35517
+ }
35518
+ }
35519
+ namespace V2UsersSelfPasskeyChallenges {
35520
+ namespace Post {
35521
+ namespace Parameters {
35522
+ type Path = {};
35523
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
35524
+ type Query = {};
35525
+ }
35526
+ namespace Responses {
35527
+ namespace $201 {
35528
+ namespace Content {
35529
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.SignupPasskeyChallenge;
35530
+ }
35531
+ }
35532
+ namespace $400 {
35533
+ namespace Content {
35534
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsError;
35535
+ }
35536
+ }
35537
+ namespace $429 {
35538
+ namespace Content {
35539
+ interface ApplicationJson {
35540
+ [k: string]: unknown;
35541
+ }
35542
+ }
35543
+ }
35544
+ namespace $500 {
35545
+ namespace Content {
35546
+ interface ApplicationJson {
35547
+ [k: string]: unknown;
35548
+ }
35549
+ }
35550
+ }
35551
+ namespace Default {
35552
+ namespace Content {
35553
+ interface ApplicationJson {
35554
+ [k: string]: unknown;
35555
+ }
35556
+ }
35557
+ }
35558
+ }
35559
+ }
35560
+ }
35561
+ namespace V2UsersSelfPasskeyRegistrationChallenges {
35562
+ namespace Post {
35563
+ namespace Parameters {
35564
+ type Path = {};
35565
+ interface RequestBody {
35566
+ /**
35567
+ * A TOTP code or recovery code.
35568
+ */
35569
+ multiFactorCode?: string;
35570
+ passkeyCredential?: MittwaldAPIV2.Components.Schemas.SignupPasskeyCredential;
35571
+ /**
35572
+ * The password of the user.
35573
+ */
35574
+ password: string;
35575
+ }
35576
+ type Header = {} & MittwaldAPIV2.Components.SecuritySchemes.CommonsAccessToken;
35577
+ type Query = {};
35578
+ }
35579
+ namespace Responses {
35580
+ namespace $201 {
35581
+ namespace Content {
35582
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.SignupPasskeyRegistrationChallenge;
35583
+ }
35584
+ }
35585
+ namespace $202 {
35586
+ namespace Content {
35587
+ interface ApplicationJson {
35588
+ [k: string]: unknown;
35589
+ }
35590
+ }
35591
+ }
35592
+ namespace $400 {
35593
+ namespace Content {
35594
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsValidationErrors | MittwaldAPIV2.Components.Schemas.CommonsError;
35595
+ }
35596
+ }
35597
+ namespace $412 {
35598
+ namespace Content {
35599
+ type ApplicationJson = MittwaldAPIV2.Components.Schemas.CommonsError;
35600
+ }
35601
+ }
35602
+ namespace $429 {
35603
+ namespace Content {
35604
+ interface ApplicationJson {
35605
+ [k: string]: unknown;
35606
+ }
35607
+ }
35608
+ }
35609
+ namespace $500 {
35610
+ namespace Content {
35611
+ interface ApplicationJson {
35612
+ [k: string]: unknown;
35613
+ }
35614
+ }
35615
+ }
35616
+ namespace Default {
35617
+ namespace Content {
35618
+ interface ApplicationJson {
35619
+ [k: string]: unknown;
35620
+ }
35621
+ }
35622
+ }
35623
+ }
35624
+ }
35625
+ }
34806
35626
  }
34807
35627
  }