@absolutejs/auth 0.65.5 → 0.66.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.
Files changed (61) hide show
  1. package/dist/agents/context.d.ts +5 -18
  2. package/dist/agents/index.js +3 -3
  3. package/dist/agents/index.js.map +3 -3
  4. package/dist/agents/routes.d.ts +24 -56
  5. package/dist/apikeys/routes.d.ts +169 -78
  6. package/dist/authContext.d.ts +34 -79
  7. package/dist/authorization/protectPermission.d.ts +11 -23
  8. package/dist/cli/migrate.js +2 -2
  9. package/dist/cli/migrate.js.map +4 -4
  10. package/dist/compliance/routes.d.ts +179 -54
  11. package/dist/credentials/emailVerification.d.ts +173 -56
  12. package/dist/credentials/login.d.ts +192 -63
  13. package/dist/credentials/passwordReset.d.ts +171 -60
  14. package/dist/credentials/register.d.ts +182 -41
  15. package/dist/credentials/routes.d.ts +46 -36
  16. package/dist/htmx/configuredRoutes.d.ts +263 -114
  17. package/dist/htmx/routes.d.ts +261 -89
  18. package/dist/index.d.ts +663 -443
  19. package/dist/index.js +475 -448
  20. package/dist/index.js.map +48 -48
  21. package/dist/manifest.js +86 -4
  22. package/dist/manifest.js.map +3 -3
  23. package/dist/mfa/challenge.d.ts +189 -59
  24. package/dist/mfa/management.d.ts +179 -54
  25. package/dist/mfa/routes.d.ts +34 -40
  26. package/dist/mfa/sms.d.ts +187 -59
  27. package/dist/mfa/totp.d.ts +187 -57
  28. package/dist/oidc/routes.d.ts +73 -74
  29. package/dist/oidc/vciRoutes.d.ts +9 -45
  30. package/dist/organizations/routes.d.ts +215 -77
  31. package/dist/passwordless/routes.d.ts +22 -34
  32. package/dist/portal/routes.d.ts +162 -55
  33. package/dist/roles/routes.d.ts +198 -67
  34. package/dist/routes/authorize.d.ts +182 -90
  35. package/dist/routes/callback.d.ts +189 -38
  36. package/dist/routes/profile.d.ts +177 -51
  37. package/dist/routes/protectRoute.d.ts +11 -23
  38. package/dist/routes/refresh.d.ts +177 -51
  39. package/dist/routes/requireAuth.d.ts +9 -21
  40. package/dist/routes/revoke.d.ts +177 -51
  41. package/dist/routes/sessions.d.ts +187 -61
  42. package/dist/routes/signout.d.ts +174 -50
  43. package/dist/routes/stepUp.d.ts +11 -23
  44. package/dist/routes/userStatus.d.ts +174 -52
  45. package/dist/scim/routes.d.ts +208 -73
  46. package/dist/server.js +475 -448
  47. package/dist/server.js.map +48 -48
  48. package/dist/session/cleanup.d.ts +5 -18
  49. package/dist/session/state.d.ts +3 -23
  50. package/dist/sso/discoveryRoute.d.ts +158 -52
  51. package/dist/sso/oidcRoutes.d.ts +211 -59
  52. package/dist/sso/samlIdpRoutes.d.ts +175 -46
  53. package/dist/sso/samlRoutes.d.ts +217 -69
  54. package/dist/typebox.d.ts +4 -4
  55. package/dist/types.d.ts +3 -5
  56. package/dist/vault/index.js +3 -3
  57. package/dist/vault/index.js.map +3 -3
  58. package/dist/vc/statusListRoutes.d.ts +158 -52
  59. package/dist/vc/vpRoutes.d.ts +170 -66
  60. package/dist/webauthn/routes.d.ts +199 -66
  61. package/package.json +8 -120
package/dist/index.d.ts CHANGED
@@ -1,6 +1,6 @@
1
1
  import { Elysia } from 'elysia';
2
2
  import type { AuthConfig } from './types';
3
- export declare const auth: <UserType>(configuration: AuthConfig<UserType>) => Promise<Elysia<"", {
3
+ export declare const auth: <UserType>(configuration: AuthConfig<UserType>) => Promise<Elysia<"", "local", {
4
4
  decorator: {};
5
5
  store: {
6
6
  session: import("./types").SessionRecord<UserType>;
@@ -13,12 +13,12 @@ export declare const auth: <UserType>(configuration: AuthConfig<UserType>) => Pr
13
13
  } | {
14
14
  readonly code: "Unauthorized";
15
15
  readonly message: "User is not authenticated";
16
- }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
16
+ }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
17
17
  } & {
18
18
  readonly requireRecentAuth: <AuthReturn, AuthFailReturn_1>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
19
19
  readonly code: "Unauthorized";
20
20
  readonly message: "Recent authentication required";
21
- }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
21
+ }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
22
22
  } & {
23
23
  readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
24
24
  code: "Forbidden" | "Unauthorized";
@@ -31,12 +31,12 @@ export declare const auth: <UserType>(configuration: AuthConfig<UserType>) => Pr
31
31
  } | {
32
32
  readonly code: "Unauthorized";
33
33
  readonly message: "User is not authenticated";
34
- }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
34
+ }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
35
35
  } & {
36
36
  readonly requireRecentAuth: <AuthReturn, AuthFailReturn_1>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
37
37
  readonly code: "Unauthorized";
38
38
  readonly message: "Recent authentication required";
39
- }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
39
+ }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
40
40
  } & {
41
41
  readonly protectPermission: <AuthReturn, AuthFailReturn_3>(check: import(".").PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
42
42
  readonly code: "Bad Request";
@@ -47,87 +47,65 @@ export declare const auth: <UserType>(configuration: AuthConfig<UserType>) => Pr
47
47
  } | {
48
48
  readonly code: "Unauthorized";
49
49
  readonly message: "User is not authenticated";
50
- }) => AuthFailReturn_3) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
50
+ }) => AuthFailReturn_3) | undefined) => Promise<import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaStatus<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
51
51
  } & {
52
52
  readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
53
53
  code: "Forbidden" | "Unauthorized";
54
54
  message: "Agent is not authenticated" | "Insufficient agent scopes";
55
55
  }) => AuthFailReturn_2 | Promise<AuthFailReturn_2>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn_2>>>;
56
56
  });
57
- resolve: {};
58
57
  }, {
59
58
  typebox: {};
60
- error: {};
61
- } & {
62
- typebox: {};
63
- error: {};
64
- }, {
65
- schema: {};
66
- standaloneSchema: {};
67
- macro: {};
68
- macroFn: {};
69
- parser: {};
70
- response: {};
71
- } & (({
59
+ error: [];
60
+ }, import("elysia/types").DefaultMetadata & ((import("elysia/types").DefaultMetadata & ({
72
61
  schema: {};
73
- standaloneSchema: {};
74
- macro: {};
75
- macroFn: {};
76
- parser: {};
77
- response: {};
78
- } & ({
79
- schema: import("elysia").UnwrapRoute<{
80
- cookie: import("@sinclair/typebox").TObject<{
81
- user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
62
+ schemas: import("elysia").UnwrapRoute<{
63
+ cookie: import("elysia").TCookieObject<{
64
+ user_session_id: import("typebox").TOptional<import("typebox").TTemplateLiteral<"^.*-.*-.*-.*-.*$">>;
82
65
  }>;
66
+ schema: "merge";
83
67
  }, {}, "">;
84
- standaloneSchema: {};
85
68
  macro: {};
86
69
  macroFn: {};
87
70
  parser: {};
88
- response: import("elysia").ExtractErrorFromHandle<{
71
+ response: import("elysia/types").ExtractErrorFromHandle<{
89
72
  readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
90
73
  readonly code: "Bad Request";
91
74
  readonly message: "Cookies are missing";
92
75
  } | {
93
76
  readonly code: "Unauthorized";
94
77
  readonly message: "User is not authenticated";
95
- }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
78
+ }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
96
79
  }>;
97
80
  } & ({
98
- schema: import("elysia").UnwrapRoute<{
99
- cookie: import("@sinclair/typebox").TObject<{
100
- user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
81
+ schema: {};
82
+ schemas: import("elysia").UnwrapRoute<{
83
+ cookie: import("elysia").TCookieObject<{
84
+ user_session_id: import("typebox").TOptional<import("typebox").TTemplateLiteral<"^.*-.*-.*-.*-.*$">>;
101
85
  }>;
86
+ schema: "merge";
102
87
  }, {}, "">;
103
- standaloneSchema: {};
104
88
  macro: {};
105
89
  macroFn: {};
106
90
  parser: {};
107
- response: import("elysia").ExtractErrorFromHandle<{
91
+ response: import("elysia/types").ExtractErrorFromHandle<{
108
92
  readonly requireRecentAuth: <AuthReturn, AuthFailReturn_1>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
109
93
  readonly code: "Unauthorized";
110
94
  readonly message: "Recent authentication required";
111
- }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
95
+ }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
112
96
  }>;
113
- } & ({
97
+ } & (import("elysia/types").DefaultMetadata | {
114
98
  schema: {};
115
- standaloneSchema: {};
116
- macro: {};
117
- macroFn: {};
118
- parser: {};
119
- response: {};
120
- } | {
121
- schema: import("elysia").UnwrapRoute<{
122
- cookie: import("@sinclair/typebox").TObject<{
123
- user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
99
+ schemas: import("elysia").UnwrapRoute<{
100
+ cookie: import("elysia").TCookieObject<{
101
+ user_session_id: import("typebox").TOptional<import("typebox").TTemplateLiteral<"^.*-.*-.*-.*-.*$">>;
124
102
  }>;
103
+ schema: "merge";
125
104
  }, {}, "">;
126
- standaloneSchema: {};
127
105
  macro: {};
128
106
  macroFn: {};
129
107
  parser: {};
130
- response: import("elysia").ExtractErrorFromHandle<{
108
+ response: import("elysia/types").ExtractErrorFromHandle<{
131
109
  readonly protectPermission: <AuthReturn, AuthFailReturn_3>(check: import(".").PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
132
110
  readonly code: "Bad Request";
133
111
  readonly message: "Cookies are missing";
@@ -137,41 +115,29 @@ export declare const auth: <UserType>(configuration: AuthConfig<UserType>) => Pr
137
115
  } | {
138
116
  readonly code: "Unauthorized";
139
117
  readonly message: "User is not authenticated";
140
- }) => AuthFailReturn_3) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
118
+ }) => AuthFailReturn_3) | undefined) => Promise<import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaStatus<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
141
119
  }>;
142
120
  })))) & {
143
121
  schema: {};
144
- standaloneSchema: {};
122
+ schemas: {};
145
123
  macro: {};
146
124
  macroFn: {};
147
125
  parser: {};
148
- response: import("elysia").ExtractErrorFromHandle<{
126
+ response: import("elysia/types").ExtractErrorFromHandle<{
149
127
  readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
150
128
  code: "Forbidden" | "Unauthorized";
151
129
  message: "Agent is not authenticated" | "Insufficient agent scopes";
152
130
  }) => AuthFailReturn_2 | Promise<AuthFailReturn_2>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn_2>>>;
153
131
  }>;
154
- }), {}, {
132
+ }), {}, import("elysia/types").DefaultEphemeral, {
155
133
  derive: {};
156
- resolve: {};
157
134
  schema: {};
158
- standaloneSchema: {};
159
- response: {};
160
- }, {
161
- derive: {};
162
- resolve: {};
163
- schema: {};
164
- standaloneSchema: {};
165
- response: {};
166
- } & {
167
- derive: {};
168
- resolve: {};
169
- schema: {};
170
- standaloneSchema: {};
135
+ schemas: {};
171
136
  response: {};
137
+ error: [];
172
138
  }>>;
173
139
  export declare const createAuthApplications: <UserType>(configuration: AuthConfig<UserType>) => Promise<{
174
- authContext: Elysia<"", {
140
+ authContext: Elysia<"", "local", {
175
141
  decorator: {};
176
142
  store: {
177
143
  session: import("./types").SessionRecord<UserType>;
@@ -184,12 +150,12 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
184
150
  } | {
185
151
  readonly code: "Unauthorized";
186
152
  readonly message: "User is not authenticated";
187
- }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
153
+ }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
188
154
  } & {
189
155
  readonly requireRecentAuth: <AuthReturn, AuthFailReturn_1>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
190
156
  readonly code: "Unauthorized";
191
157
  readonly message: "Recent authentication required";
192
- }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
158
+ }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
193
159
  } & {
194
160
  readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
195
161
  code: "Forbidden" | "Unauthorized";
@@ -202,12 +168,12 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
202
168
  } | {
203
169
  readonly code: "Unauthorized";
204
170
  readonly message: "User is not authenticated";
205
- }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
171
+ }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
206
172
  } & {
207
173
  readonly requireRecentAuth: <AuthReturn, AuthFailReturn_1>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
208
174
  readonly code: "Unauthorized";
209
175
  readonly message: "Recent authentication required";
210
- }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
176
+ }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
211
177
  } & {
212
178
  readonly protectPermission: <AuthReturn, AuthFailReturn_3>(check: import(".").PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
213
179
  readonly code: "Bad Request";
@@ -218,80 +184,65 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
218
184
  } | {
219
185
  readonly code: "Unauthorized";
220
186
  readonly message: "User is not authenticated";
221
- }) => AuthFailReturn_3) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
187
+ }) => AuthFailReturn_3) | undefined) => Promise<import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaStatus<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
222
188
  } & {
223
189
  readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
224
190
  code: "Forbidden" | "Unauthorized";
225
191
  message: "Agent is not authenticated" | "Insufficient agent scopes";
226
192
  }) => AuthFailReturn_2 | Promise<AuthFailReturn_2>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn_2>>>;
227
193
  });
228
- resolve: {};
229
194
  }, {
230
195
  typebox: {};
231
- error: {};
232
- } & {
233
- typebox: {};
234
- error: {};
235
- }, ({
196
+ error: [];
197
+ }, (import("elysia/types").DefaultMetadata & ({
236
198
  schema: {};
237
- standaloneSchema: {};
238
- macro: {};
239
- macroFn: {};
240
- parser: {};
241
- response: {};
242
- } & ({
243
- schema: import("elysia").UnwrapRoute<{
244
- cookie: import("@sinclair/typebox").TObject<{
245
- user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
199
+ schemas: import("elysia").UnwrapRoute<{
200
+ cookie: import("elysia").TCookieObject<{
201
+ user_session_id: import("typebox").TOptional<import("typebox").TTemplateLiteral<"^.*-.*-.*-.*-.*$">>;
246
202
  }>;
203
+ schema: "merge";
247
204
  }, {}, "">;
248
- standaloneSchema: {};
249
205
  macro: {};
250
206
  macroFn: {};
251
207
  parser: {};
252
- response: import("elysia").ExtractErrorFromHandle<{
208
+ response: import("elysia/types").ExtractErrorFromHandle<{
253
209
  readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
254
210
  readonly code: "Bad Request";
255
211
  readonly message: "Cookies are missing";
256
212
  } | {
257
213
  readonly code: "Unauthorized";
258
214
  readonly message: "User is not authenticated";
259
- }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
215
+ }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
260
216
  }>;
261
217
  } & ({
262
- schema: import("elysia").UnwrapRoute<{
263
- cookie: import("@sinclair/typebox").TObject<{
264
- user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
218
+ schema: {};
219
+ schemas: import("elysia").UnwrapRoute<{
220
+ cookie: import("elysia").TCookieObject<{
221
+ user_session_id: import("typebox").TOptional<import("typebox").TTemplateLiteral<"^.*-.*-.*-.*-.*$">>;
265
222
  }>;
223
+ schema: "merge";
266
224
  }, {}, "">;
267
- standaloneSchema: {};
268
225
  macro: {};
269
226
  macroFn: {};
270
227
  parser: {};
271
- response: import("elysia").ExtractErrorFromHandle<{
228
+ response: import("elysia/types").ExtractErrorFromHandle<{
272
229
  readonly requireRecentAuth: <AuthReturn, AuthFailReturn_1>(maxAgeMs: number, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
273
230
  readonly code: "Unauthorized";
274
231
  readonly message: "Recent authentication required";
275
- }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
232
+ }) => AuthFailReturn_1) | undefined) => Promise<import("elysia").ElysiaStatus<"Unauthorized", "Recent authentication required", 401> | AuthReturn | NonNullable<AuthFailReturn_1>>;
276
233
  }>;
277
- } & ({
234
+ } & (import("elysia/types").DefaultMetadata | {
278
235
  schema: {};
279
- standaloneSchema: {};
280
- macro: {};
281
- macroFn: {};
282
- parser: {};
283
- response: {};
284
- } | {
285
- schema: import("elysia").UnwrapRoute<{
286
- cookie: import("@sinclair/typebox").TObject<{
287
- user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
236
+ schemas: import("elysia").UnwrapRoute<{
237
+ cookie: import("elysia").TCookieObject<{
238
+ user_session_id: import("typebox").TOptional<import("typebox").TTemplateLiteral<"^.*-.*-.*-.*-.*$">>;
288
239
  }>;
240
+ schema: "merge";
289
241
  }, {}, "">;
290
- standaloneSchema: {};
291
242
  macro: {};
292
243
  macroFn: {};
293
244
  parser: {};
294
- response: import("elysia").ExtractErrorFromHandle<{
245
+ response: import("elysia/types").ExtractErrorFromHandle<{
295
246
  readonly protectPermission: <AuthReturn, AuthFailReturn_3>(check: import(".").PermissionCheck, handleAuth: (user: UserType) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
296
247
  readonly code: "Bad Request";
297
248
  readonly message: "Cookies are missing";
@@ -301,58 +252,28 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
301
252
  } | {
302
253
  readonly code: "Unauthorized";
303
254
  readonly message: "User is not authenticated";
304
- }) => AuthFailReturn_3) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaCustomStatusResponse<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
255
+ }) => AuthFailReturn_3) | undefined) => Promise<import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | import("elysia").ElysiaStatus<"Forbidden", "Insufficient permissions", 403> | AuthReturn | NonNullable<AuthFailReturn_3>>;
305
256
  }>;
306
257
  })))) & {
307
258
  schema: {};
308
- standaloneSchema: {};
259
+ schemas: {};
309
260
  macro: {};
310
261
  macroFn: {};
311
262
  parser: {};
312
- response: import("elysia").ExtractErrorFromHandle<{
263
+ response: import("elysia/types").ExtractErrorFromHandle<{
313
264
  readonly protectAgent: <AuthReturn, AuthFailReturn_2>(requiredScopes: string[], handleAuth: (principal: import(".").AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: {
314
265
  code: "Forbidden" | "Unauthorized";
315
266
  message: "Agent is not authenticated" | "Insufficient agent scopes";
316
267
  }) => AuthFailReturn_2 | Promise<AuthFailReturn_2>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn_2>>>;
317
268
  }>;
318
- }, {}, {
319
- derive: {};
320
- resolve: {};
321
- schema: {};
322
- standaloneSchema: {};
323
- response: {};
324
- }, ({
325
- derive: {};
326
- resolve: {};
327
- schema: {};
328
- standaloneSchema: {};
329
- response: {};
330
- } & {
331
- derive: {};
332
- resolve: {};
333
- schema: {};
334
- standaloneSchema: {};
335
- response: {};
336
- }) | ({
337
- derive: {};
338
- resolve: {};
339
- schema: {};
340
- standaloneSchema: {};
341
- response: {};
342
- } & {
343
- derive: {};
344
- resolve: {};
345
- schema: {};
346
- standaloneSchema: {};
347
- response: {};
348
- } & {
269
+ }, {}, import("elysia/types").DefaultEphemeral, {
349
270
  derive: {};
350
- resolve: {};
351
271
  schema: {};
352
- standaloneSchema: {};
272
+ schemas: {};
353
273
  response: {};
354
- })>;
355
- coreRoutes: Elysia<"", {
274
+ error: [];
275
+ }>;
276
+ coreRoutes: Elysia<"", "local", {
356
277
  decorator: {};
357
278
  store: {
358
279
  session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<NoInfer<UserType>>;
@@ -361,36 +282,18 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
361
282
  derive: {
362
283
  readonly cleanupSessions: () => Promise<void>;
363
284
  };
364
- resolve: {};
365
285
  }, {
366
286
  typebox: {};
367
- error: {};
368
- } & {
369
- typebox: {};
370
- error: {};
371
- }, {
372
- schema: {};
373
- standaloneSchema: {};
374
- macro: {};
375
- macroFn: {};
376
- parser: {};
377
- response: {};
378
- } & {
287
+ error: [];
288
+ }, import("elysia/types").DefaultMetadata & {
379
289
  schema: {};
380
- standaloneSchema: {};
290
+ schemas: {};
381
291
  macro: {};
382
292
  macroFn: {};
383
293
  parser: {};
384
- response: import("elysia").ExtractErrorFromHandle<{
294
+ response: import("elysia/types").ExtractErrorFromHandle<{
385
295
  readonly cleanupSessions: () => Promise<void>;
386
296
  }>;
387
- } & {
388
- schema: {};
389
- standaloneSchema: {};
390
- macro: {};
391
- macroFn: {};
392
- parser: {};
393
- response: {};
394
297
  }, (({
395
298
  [x: string]: {
396
299
  delete: {
@@ -404,15 +307,17 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
404
307
  200: Response;
405
308
  422: {
406
309
  type: "validation";
310
+ title: "Validation Error";
311
+ status: 422;
312
+ detail?: string;
407
313
  on: string;
408
- summary?: string;
409
- message?: string;
410
314
  found?: unknown;
411
315
  property?: string;
412
316
  expected?: string;
413
317
  };
414
318
  500: "Sign out operation failed";
415
319
  };
320
+ error: never;
416
321
  };
417
322
  };
418
323
  } & {
@@ -429,15 +334,17 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
429
334
  200: Response;
430
335
  422: {
431
336
  type: "validation";
337
+ title: "Validation Error";
338
+ status: 422;
339
+ detail?: string;
432
340
  on: string;
433
- summary?: string;
434
- message?: string;
435
341
  found?: unknown;
436
342
  property?: string;
437
343
  expected?: string;
438
344
  };
439
345
  500: "Failed to revoke token";
440
346
  };
347
+ error: never;
441
348
  };
442
349
  };
443
350
  } & ({
@@ -455,15 +362,17 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
455
362
  };
456
363
  422: {
457
364
  type: "validation";
365
+ title: "Validation Error";
366
+ status: 422;
367
+ detail?: string;
458
368
  on: string;
459
- summary?: string;
460
- message?: string;
461
369
  found?: unknown;
462
370
  property?: string;
463
371
  expected?: string;
464
372
  };
465
373
  500: `Error: ${string} - ${string}` | `Unknown Error: ${string}`;
466
374
  };
375
+ error: never;
467
376
  };
468
377
  };
469
378
  } & ({
@@ -480,15 +389,17 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
480
389
  200: Response;
481
390
  422: {
482
391
  type: "validation";
392
+ title: "Validation Error";
393
+ status: 422;
394
+ detail?: string;
483
395
  on: string;
484
- summary?: string;
485
- message?: string;
486
396
  found?: unknown;
487
397
  property?: string;
488
398
  expected?: string;
489
399
  };
490
400
  500: "Failed to refresh token";
491
401
  };
402
+ error: never;
492
403
  };
493
404
  };
494
405
  } & ({
@@ -510,15 +421,17 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
510
421
  200: Response;
511
422
  422: {
512
423
  type: "validation";
424
+ title: "Validation Error";
425
+ status: 422;
426
+ detail?: string;
513
427
  on: string;
514
- summary?: string;
515
- message?: string;
516
428
  found?: unknown;
517
429
  property?: string;
518
430
  expected?: string;
519
431
  };
520
432
  500: "Failed to create authorization URL";
521
433
  };
434
+ error: never;
522
435
  };
523
436
  };
524
437
  };
@@ -542,15 +455,17 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
542
455
  200: Response;
543
456
  422: {
544
457
  type: "validation";
458
+ title: "Validation Error";
459
+ status: 422;
460
+ detail?: string;
545
461
  on: string;
546
- summary?: string;
547
- message?: string;
548
462
  found?: unknown;
549
463
  property?: string;
550
464
  expected?: string;
551
465
  };
552
466
  500: "Failed to create authorization URL";
553
467
  };
468
+ error: never;
554
469
  };
555
470
  };
556
471
  };
@@ -563,8 +478,19 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
563
478
  query: unknown;
564
479
  headers: unknown;
565
480
  response: {
566
- [x: number]: {};
481
+ 200: Response | import("./types").StatusReturn;
482
+ 422: {
483
+ type: "validation";
484
+ title: "Validation Error";
485
+ status: 422;
486
+ detail?: string;
487
+ on: string;
488
+ found?: unknown;
489
+ property?: string;
490
+ expected?: string;
491
+ };
567
492
  };
493
+ error: never;
568
494
  };
569
495
  };
570
496
  }) & {
@@ -581,43 +507,27 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
581
507
  200: Response;
582
508
  422: {
583
509
  type: "validation";
510
+ title: "Validation Error";
511
+ status: 422;
512
+ detail?: string;
584
513
  on: string;
585
- summary?: string;
586
- message?: string;
587
514
  found?: unknown;
588
515
  property?: string;
589
516
  expected?: string;
590
517
  };
591
518
  500: `${string} - ${string}` | `Failed to validate authorization code: Unknown status: ${string}`;
592
519
  };
520
+ error: never;
593
521
  };
594
522
  };
595
- }, {
523
+ }, import("elysia/types").DefaultEphemeral, {
596
524
  derive: {};
597
- resolve: {};
598
525
  schema: {};
599
- standaloneSchema: {};
600
- response: {};
601
- }, {
602
- derive: {};
603
- resolve: {};
604
- schema: {};
605
- standaloneSchema: {};
606
- response: {};
607
- } & {
608
- derive: {};
609
- resolve: {};
610
- schema: {};
611
- standaloneSchema: {};
612
- response: {};
613
- } & {
614
- derive: {};
615
- resolve: {};
616
- schema: {};
617
- standaloneSchema: {};
526
+ schemas: {};
618
527
  response: {};
528
+ error: [];
619
529
  }>;
620
- featureRoutes: Elysia<"", {
530
+ featureRoutes: Elysia<"", "local", {
621
531
  decorator: {};
622
532
  store: {} | {
623
533
  session: import("./types").SessionRecord<import(".").AuthHtmxUser>;
@@ -625,42 +535,186 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
625
535
  } | {
626
536
  session: import("./types").SessionRecord<UserType>;
627
537
  unregisteredSession: import("./types").UnregisteredSessionRecord;
538
+ } | {
539
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
540
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
628
541
  } | {
629
542
  session: import("./types").SessionRecord<UserType>;
630
543
  unregisteredSession: import("./types").UnregisteredSessionRecord;
544
+ } | {
545
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
546
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
631
547
  } | {
632
548
  session: import("./types").SessionRecord<UserType>;
633
549
  unregisteredSession: import("./types").UnregisteredSessionRecord;
550
+ } | {
551
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
552
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
634
553
  } | {
635
554
  session: import("./types").SessionRecord<UserType>;
636
555
  unregisteredSession: import("./types").UnregisteredSessionRecord;
556
+ } | {
557
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
558
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
637
559
  } | {
638
560
  session: import("./types").SessionRecord<UserType>;
639
561
  unregisteredSession: import("./types").UnregisteredSessionRecord;
562
+ } | {
563
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
564
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
640
565
  } | {
641
566
  session: import("./types").SessionRecord<UserType>;
642
567
  unregisteredSession: import("./types").UnregisteredSessionRecord;
568
+ } | {
569
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
570
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
571
+ } | {
572
+ session: import("./types").SessionRecord<UserType>;
573
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
574
+ } | {
575
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
576
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
577
+ } | {
578
+ session: import("./types").SessionRecord<UserType>;
579
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
580
+ } | {
581
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
582
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
643
583
  } | {
644
584
  session: import("./types").SessionRecord<UserType>;
645
585
  unregisteredSession: import("./types").UnregisteredSessionRecord;
646
586
  } | {
647
587
  session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
648
588
  unregisteredSession: import("./types").UnregisteredSessionRecord;
589
+ } | {
590
+ session: import("./types").SessionRecord<UserType>;
591
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
649
592
  } | {
650
593
  session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
651
594
  unregisteredSession: import("./types").UnregisteredSessionRecord;
595
+ } | {
596
+ session: import("./types").SessionRecord<UserType>;
597
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
652
598
  } | {
653
599
  session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
654
600
  unregisteredSession: import("./types").UnregisteredSessionRecord;
601
+ } | {
602
+ session: import("./types").SessionRecord<UserType>;
603
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
655
604
  } | {
656
605
  session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
657
606
  unregisteredSession: import("./types").UnregisteredSessionRecord;
607
+ } | {
608
+ session: import("./types").SessionRecord<UserType>;
609
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
658
610
  } | {
659
611
  session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
660
612
  unregisteredSession: import("./types").UnregisteredSessionRecord;
613
+ } | {
614
+ session: import("./types").SessionRecord<UserType>;
615
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
661
616
  } | {
662
617
  session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
663
618
  unregisteredSession: import("./types").UnregisteredSessionRecord;
619
+ } | {
620
+ session: import("./types").SessionRecord<UserType>;
621
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
622
+ } | {
623
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
624
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
625
+ } | {
626
+ session: import("./types").SessionRecord<UserType>;
627
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
628
+ } | {
629
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
630
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
631
+ } | {
632
+ session: import("./types").SessionRecord<UserType>;
633
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
634
+ } | {
635
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
636
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
637
+ } | {
638
+ session: import("./types").SessionRecord<UserType>;
639
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
640
+ } | {
641
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
642
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
643
+ } | {
644
+ session: import("./types").SessionRecord<UserType>;
645
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
646
+ } | {
647
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
648
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
649
+ } | {
650
+ session: import("./types").SessionRecord<UserType>;
651
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
652
+ } | {
653
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
654
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
655
+ } | {
656
+ session: import("./types").SessionRecord<UserType>;
657
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
658
+ } | {
659
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
660
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
661
+ } | {
662
+ session: import("./types").SessionRecord<UserType>;
663
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
664
+ } | {
665
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
666
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
667
+ } | {
668
+ session: import("./types").SessionRecord<UserType>;
669
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
670
+ } | {
671
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
672
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
673
+ } | {
674
+ session: import("./types").SessionRecord<UserType>;
675
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
676
+ } | {
677
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
678
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
679
+ } | {
680
+ session: import("./types").SessionRecord<UserType>;
681
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
682
+ } | {
683
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
684
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
685
+ } | {
686
+ session: import("./types").SessionRecord<UserType>;
687
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
688
+ } | {
689
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
690
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
691
+ } | {
692
+ session: import("./types").SessionRecord<UserType>;
693
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
694
+ } | {
695
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
696
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
697
+ } | {
698
+ session: import("./types").SessionRecord<UserType>;
699
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
700
+ } | {
701
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
702
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
703
+ } | {
704
+ session: import("./types").SessionRecord<UserType>;
705
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
706
+ } | {
707
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
708
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
709
+ } | {
710
+ session: import("./types").SessionRecord<UserType>;
711
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
712
+ } | {
713
+ session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
714
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
715
+ } | {
716
+ session: import("./types").SessionRecord<UserType>;
717
+ unregisteredSession: import("./types").UnregisteredSessionRecord;
664
718
  } | {
665
719
  session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<import(".").AuthHtmxUser>;
666
720
  unregisteredSession: import("./types").UnregisteredSessionRecord;
@@ -672,70 +726,46 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
672
726
  } | {
673
727
  readonly code: "Unauthorized";
674
728
  readonly message: "User is not authenticated";
675
- }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
729
+ }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
676
730
  };
677
- resolve: {};
678
731
  }, {
679
732
  typebox: {};
680
- error: {};
681
- } & {
682
- typebox: {};
683
- error: {};
684
- }, (({
685
- schema: {};
686
- standaloneSchema: {};
687
- macro: {};
688
- macroFn: {};
689
- parser: {};
690
- response: {};
691
- } & {
733
+ error: [];
734
+ }, (import("elysia/types").DefaultMetadata & {
692
735
  schema: {};
693
- standaloneSchema: {};
736
+ schemas: {};
694
737
  macro: {};
695
738
  macroFn: {};
696
739
  parser: {};
697
740
  response: {};
698
- }) | ({
741
+ }) | (import("elysia/types").DefaultMetadata & {
699
742
  schema: {};
700
- standaloneSchema: {};
701
- macro: {};
702
- macroFn: {};
703
- parser: {};
704
- response: {};
705
- } & {
706
- schema: {};
707
- standaloneSchema: {};
708
- macro: {};
709
- macroFn: {};
710
- parser: {};
711
- response: {};
712
- } & {
713
- schema: import("elysia").UnwrapRoute<{
714
- cookie: import("@sinclair/typebox").TObject<{
715
- user_session_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TTemplateLiteralSyntax<"${string}-${string}-${string}-${string}-${string}">>;
743
+ schemas: import("elysia").UnwrapRoute<{
744
+ cookie: import("elysia").TCookieObject<{
745
+ user_session_id: import("typebox").TOptional<import("typebox").TTemplateLiteral<"^.*-.*-.*-.*-.*$">>;
716
746
  }>;
747
+ schema: "merge";
717
748
  }, {}, "">;
718
- standaloneSchema: {};
719
749
  macro: {};
720
750
  macroFn: {};
721
751
  parser: {};
722
- response: import("elysia").ExtractErrorFromHandle<{
752
+ response: import("elysia/types").ExtractErrorFromHandle<{
723
753
  readonly protectRoute: <AuthReturn, AuthFailReturn = never>(handleAuth: (user: import(".").AuthHtmxUser) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: ((error: {
724
754
  readonly code: "Bad Request";
725
755
  readonly message: "Cookies are missing";
726
756
  } | {
727
757
  readonly code: "Unauthorized";
728
758
  readonly message: "User is not authenticated";
729
- }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaCustomStatusResponse<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
759
+ }) => AuthFailReturn) | undefined) => Promise<import("elysia").ElysiaStatus<"Bad Request", "Cookies are missing", 400> | import("elysia").ElysiaStatus<"Unauthorized", "User is not authenticated", 401> | AuthReturn | NonNullable<AuthFailReturn>>;
730
760
  }>;
731
- })) & {
761
+ } & {
732
762
  schema: {};
733
- standaloneSchema: {};
763
+ schemas: {};
734
764
  macro: {};
735
765
  macroFn: {};
736
766
  parser: {};
737
767
  response: {};
738
- }, (((((((((((((((({} | ({
768
+ }), (({} & (((((({} | ({
739
769
  [x: string]: {
740
770
  post: {
741
771
  body: {
@@ -746,8 +776,19 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
746
776
  query: unknown;
747
777
  headers: unknown;
748
778
  response: {
749
- [x: number]: {};
779
+ 200: Response | import("./types").StatusReturn;
780
+ 422: {
781
+ type: "validation";
782
+ title: "Validation Error";
783
+ status: 422;
784
+ detail?: string;
785
+ on: string;
786
+ found?: unknown;
787
+ property?: string;
788
+ expected?: string;
789
+ };
750
790
  };
791
+ error: never;
751
792
  };
752
793
  };
753
794
  } & {
@@ -760,8 +801,19 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
760
801
  query: unknown;
761
802
  headers: unknown;
762
803
  response: {
763
- [x: number]: {};
804
+ 200: Response | import("./types").StatusReturn;
805
+ 422: {
806
+ type: "validation";
807
+ title: "Validation Error";
808
+ status: 422;
809
+ detail?: string;
810
+ on: string;
811
+ found?: unknown;
812
+ property?: string;
813
+ expected?: string;
814
+ };
764
815
  };
816
+ error: never;
765
817
  };
766
818
  };
767
819
  } & {
@@ -780,14 +832,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
780
832
  };
781
833
  422: {
782
834
  type: "validation";
835
+ title: "Validation Error";
836
+ status: 422;
837
+ detail?: string;
783
838
  on: string;
784
- summary?: string;
785
- message?: string;
786
839
  found?: unknown;
787
840
  property?: string;
788
841
  expected?: string;
789
842
  };
790
843
  };
844
+ error: never;
791
845
  };
792
846
  };
793
847
  };
@@ -814,9 +868,10 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
814
868
  };
815
869
  422: {
816
870
  type: "validation";
871
+ title: "Validation Error";
872
+ status: 422;
873
+ detail?: string;
817
874
  on: string;
818
- summary?: string;
819
- message?: string;
820
875
  found?: unknown;
821
876
  property?: string;
822
877
  expected?: string;
@@ -826,6 +881,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
826
881
  readonly status: "account_locked";
827
882
  };
828
883
  };
884
+ error: never;
829
885
  };
830
886
  };
831
887
  } & {
@@ -844,14 +900,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
844
900
  };
845
901
  422: {
846
902
  type: "validation";
903
+ title: "Validation Error";
904
+ status: 422;
905
+ detail?: string;
847
906
  on: string;
848
- summary?: string;
849
- message?: string;
850
907
  found?: unknown;
851
908
  property?: string;
852
909
  expected?: string;
853
910
  };
854
911
  };
912
+ error: never;
855
913
  };
856
914
  };
857
915
  };
@@ -875,14 +933,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
875
933
  };
876
934
  422: {
877
935
  type: "validation";
936
+ title: "Validation Error";
937
+ status: 422;
938
+ detail?: string;
878
939
  on: string;
879
- summary?: string;
880
- message?: string;
881
940
  found?: unknown;
882
941
  property?: string;
883
942
  expected?: string;
884
943
  };
885
944
  };
945
+ error: never;
886
946
  };
887
947
  };
888
948
  })) & ({} | ({
@@ -907,14 +967,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
907
967
  };
908
968
  422: {
909
969
  type: "validation";
970
+ title: "Validation Error";
971
+ status: 422;
972
+ detail?: string;
910
973
  on: string;
911
- summary?: string;
912
- message?: string;
913
974
  found?: unknown;
914
975
  property?: string;
915
976
  expected?: string;
916
977
  };
917
978
  };
979
+ error: never;
918
980
  };
919
981
  };
920
982
  } & {
@@ -931,14 +993,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
931
993
  };
932
994
  422: {
933
995
  type: "validation";
996
+ title: "Validation Error";
997
+ status: 422;
998
+ detail?: string;
934
999
  on: string;
935
- summary?: string;
936
- message?: string;
937
1000
  found?: unknown;
938
1001
  property?: string;
939
1002
  expected?: string;
940
1003
  };
941
1004
  };
1005
+ error: never;
942
1006
  };
943
1007
  };
944
1008
  } & {
@@ -956,14 +1020,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
956
1020
  };
957
1021
  422: {
958
1022
  type: "validation";
1023
+ title: "Validation Error";
1024
+ status: 422;
1025
+ detail?: string;
959
1026
  on: string;
960
- summary?: string;
961
- message?: string;
962
1027
  found?: unknown;
963
1028
  property?: string;
964
1029
  expected?: string;
965
1030
  };
966
1031
  };
1032
+ error: never;
967
1033
  };
968
1034
  };
969
1035
  } & {
@@ -983,14 +1049,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
983
1049
  };
984
1050
  422: {
985
1051
  type: "validation";
1052
+ title: "Validation Error";
1053
+ status: 422;
1054
+ detail?: string;
986
1055
  on: string;
987
- summary?: string;
988
- message?: string;
989
1056
  found?: unknown;
990
1057
  property?: string;
991
1058
  expected?: string;
992
1059
  };
993
1060
  };
1061
+ error: never;
994
1062
  };
995
1063
  };
996
1064
  } & {
@@ -1011,9 +1079,10 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1011
1079
  };
1012
1080
  422: {
1013
1081
  type: "validation";
1082
+ title: "Validation Error";
1083
+ status: 422;
1084
+ detail?: string;
1014
1085
  on: string;
1015
- summary?: string;
1016
- message?: string;
1017
1086
  found?: unknown;
1018
1087
  property?: string;
1019
1088
  expected?: string;
@@ -1021,6 +1090,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1021
1090
  429: string;
1022
1091
  503: string;
1023
1092
  };
1093
+ error: never;
1024
1094
  };
1025
1095
  };
1026
1096
  } & {
@@ -1040,9 +1110,10 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1040
1110
  };
1041
1111
  422: {
1042
1112
  type: "validation";
1113
+ title: "Validation Error";
1114
+ status: 422;
1115
+ detail?: string;
1043
1116
  on: string;
1044
- summary?: string;
1045
- message?: string;
1046
1117
  found?: unknown;
1047
1118
  property?: string;
1048
1119
  expected?: string;
@@ -1050,6 +1121,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1050
1121
  429: string;
1051
1122
  503: string;
1052
1123
  };
1124
+ error: never;
1053
1125
  };
1054
1126
  };
1055
1127
  } & {
@@ -1073,9 +1145,10 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1073
1145
  };
1074
1146
  422: {
1075
1147
  type: "validation";
1148
+ title: "Validation Error";
1149
+ status: 422;
1150
+ detail?: string;
1076
1151
  on: string;
1077
- summary?: string;
1078
- message?: string;
1079
1152
  found?: unknown;
1080
1153
  property?: string;
1081
1154
  expected?: string;
@@ -1083,6 +1156,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1083
1156
  429: string;
1084
1157
  503: string;
1085
1158
  };
1159
+ error: never;
1086
1160
  };
1087
1161
  };
1088
1162
  }))) & {}) & ({} | ({
@@ -1105,14 +1179,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1105
1179
  };
1106
1180
  422: {
1107
1181
  type: "validation";
1182
+ title: "Validation Error";
1183
+ status: 422;
1184
+ detail?: string;
1108
1185
  on: string;
1109
- summary?: string;
1110
- message?: string;
1111
1186
  found?: unknown;
1112
1187
  property?: string;
1113
1188
  expected?: string;
1114
1189
  };
1115
1190
  };
1191
+ error: never;
1116
1192
  };
1117
1193
  };
1118
1194
  } & {
@@ -1135,14 +1211,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1135
1211
  };
1136
1212
  422: {
1137
1213
  type: "validation";
1214
+ title: "Validation Error";
1215
+ status: 422;
1216
+ detail?: string;
1138
1217
  on: string;
1139
- summary?: string;
1140
- message?: string;
1141
1218
  found?: unknown;
1142
1219
  property?: string;
1143
1220
  expected?: string;
1144
1221
  };
1145
1222
  };
1223
+ error: never;
1146
1224
  };
1147
1225
  };
1148
1226
  };
@@ -1160,14 +1238,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1160
1238
  200: Response;
1161
1239
  422: {
1162
1240
  type: "validation";
1241
+ title: "Validation Error";
1242
+ status: 422;
1243
+ detail?: string;
1163
1244
  on: string;
1164
- summary?: string;
1165
- message?: string;
1166
1245
  found?: unknown;
1167
1246
  property?: string;
1168
1247
  expected?: string;
1169
1248
  };
1170
1249
  };
1250
+ error: never;
1171
1251
  };
1172
1252
  };
1173
1253
  } & {
@@ -1188,15 +1268,17 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1188
1268
  200: Response;
1189
1269
  422: {
1190
1270
  type: "validation";
1271
+ title: "Validation Error";
1272
+ status: 422;
1273
+ detail?: string;
1191
1274
  on: string;
1192
- summary?: string;
1193
- message?: string;
1194
1275
  found?: unknown;
1195
1276
  property?: string;
1196
1277
  expected?: string;
1197
1278
  };
1198
1279
  500: "OIDC sign-in failed";
1199
1280
  };
1281
+ error: never;
1200
1282
  };
1201
1283
  };
1202
1284
  }))) & ({} | ({
@@ -1213,14 +1295,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1213
1295
  200: Response;
1214
1296
  422: {
1215
1297
  type: "validation";
1298
+ title: "Validation Error";
1299
+ status: 422;
1300
+ detail?: string;
1216
1301
  on: string;
1217
- summary?: string;
1218
- message?: string;
1219
1302
  found?: unknown;
1220
1303
  property?: string;
1221
1304
  expected?: string;
1222
1305
  };
1223
1306
  };
1307
+ error: never;
1224
1308
  };
1225
1309
  };
1226
1310
  } & {
@@ -1240,15 +1324,17 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1240
1324
  200: Response;
1241
1325
  422: {
1242
1326
  type: "validation";
1327
+ title: "Validation Error";
1328
+ status: 422;
1329
+ detail?: string;
1243
1330
  on: string;
1244
- summary?: string;
1245
- message?: string;
1246
1331
  found?: unknown;
1247
1332
  property?: string;
1248
1333
  expected?: string;
1249
1334
  };
1250
1335
  500: "SAML sign-in failed";
1251
1336
  };
1337
+ error: never;
1252
1338
  };
1253
1339
  };
1254
1340
  } & {
@@ -1265,14 +1351,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1265
1351
  200: Response;
1266
1352
  422: {
1267
1353
  type: "validation";
1354
+ title: "Validation Error";
1355
+ status: 422;
1356
+ detail?: string;
1268
1357
  on: string;
1269
- summary?: string;
1270
- message?: string;
1271
1358
  found?: unknown;
1272
1359
  property?: string;
1273
1360
  expected?: string;
1274
1361
  };
1275
1362
  };
1363
+ error: never;
1276
1364
  };
1277
1365
  };
1278
1366
  } & {
@@ -1288,14 +1376,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1288
1376
  200: Response;
1289
1377
  422: {
1290
1378
  type: "validation";
1379
+ title: "Validation Error";
1380
+ status: 422;
1381
+ detail?: string;
1291
1382
  on: string;
1292
- summary?: string;
1293
- message?: string;
1294
1383
  found?: unknown;
1295
1384
  property?: string;
1296
1385
  expected?: string;
1297
1386
  };
1298
1387
  };
1388
+ error: never;
1299
1389
  };
1300
1390
  };
1301
1391
  } & {
@@ -1320,18 +1410,20 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1320
1410
  200: Response;
1321
1411
  422: {
1322
1412
  type: "validation";
1413
+ title: "Validation Error";
1414
+ status: 422;
1415
+ detail?: string;
1323
1416
  on: string;
1324
- summary?: string;
1325
- message?: string;
1326
1417
  found?: unknown;
1327
1418
  property?: string;
1328
1419
  expected?: string;
1329
1420
  };
1330
1421
  500: "SAML logout failed";
1331
1422
  };
1423
+ error: never;
1332
1424
  };
1333
1425
  };
1334
- }))) & ({} | {
1426
+ })))) & (((((({} | {
1335
1427
  [x: string]: {
1336
1428
  get: {
1337
1429
  body: unknown;
@@ -1346,17 +1438,19 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1346
1438
  200: Response;
1347
1439
  422: {
1348
1440
  type: "validation";
1441
+ title: "Validation Error";
1442
+ status: 422;
1443
+ detail?: string;
1349
1444
  on: string;
1350
- summary?: string;
1351
- message?: string;
1352
1445
  found?: unknown;
1353
1446
  property?: string;
1354
1447
  expected?: string;
1355
1448
  };
1356
1449
  };
1450
+ error: never;
1357
1451
  };
1358
1452
  };
1359
- })) & ({} | ({
1453
+ }) & ({} | ({
1360
1454
  [x: string]: {
1361
1455
  get: {
1362
1456
  body: unknown;
@@ -1366,6 +1460,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1366
1460
  response: {
1367
1461
  200: Response;
1368
1462
  };
1463
+ error: never;
1369
1464
  };
1370
1465
  };
1371
1466
  } & {
@@ -1378,6 +1473,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1378
1473
  response: {
1379
1474
  200: Response;
1380
1475
  };
1476
+ error: never;
1381
1477
  };
1382
1478
  };
1383
1479
  } & {
@@ -1393,14 +1489,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1393
1489
  200: Response;
1394
1490
  422: {
1395
1491
  type: "validation";
1492
+ title: "Validation Error";
1493
+ status: 422;
1494
+ detail?: string;
1396
1495
  on: string;
1397
- summary?: string;
1398
- message?: string;
1399
1496
  found?: unknown;
1400
1497
  property?: string;
1401
1498
  expected?: string;
1402
1499
  };
1403
1500
  };
1501
+ error: never;
1404
1502
  };
1405
1503
  };
1406
1504
  } & {
@@ -1416,14 +1514,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1416
1514
  200: Response;
1417
1515
  422: {
1418
1516
  type: "validation";
1517
+ title: "Validation Error";
1518
+ status: 422;
1519
+ detail?: string;
1419
1520
  on: string;
1420
- summary?: string;
1421
- message?: string;
1422
1521
  found?: unknown;
1423
1522
  property?: string;
1424
1523
  expected?: string;
1425
1524
  };
1426
1525
  };
1526
+ error: never;
1427
1527
  };
1428
1528
  };
1429
1529
  } & {
@@ -1439,14 +1539,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1439
1539
  200: Response;
1440
1540
  422: {
1441
1541
  type: "validation";
1542
+ title: "Validation Error";
1543
+ status: 422;
1544
+ detail?: string;
1442
1545
  on: string;
1443
- summary?: string;
1444
- message?: string;
1445
1546
  found?: unknown;
1446
1547
  property?: string;
1447
1548
  expected?: string;
1448
1549
  };
1449
1550
  };
1551
+ error: never;
1450
1552
  };
1451
1553
  };
1452
1554
  } & {
@@ -1462,14 +1564,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1462
1564
  200: Response;
1463
1565
  422: {
1464
1566
  type: "validation";
1567
+ title: "Validation Error";
1568
+ status: 422;
1569
+ detail?: string;
1465
1570
  on: string;
1466
- summary?: string;
1467
- message?: string;
1468
1571
  found?: unknown;
1469
1572
  property?: string;
1470
1573
  expected?: string;
1471
1574
  };
1472
1575
  };
1576
+ error: never;
1473
1577
  };
1474
1578
  };
1475
1579
  } & {
@@ -1485,14 +1589,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1485
1589
  200: Response;
1486
1590
  422: {
1487
1591
  type: "validation";
1592
+ title: "Validation Error";
1593
+ status: 422;
1594
+ detail?: string;
1488
1595
  on: string;
1489
- summary?: string;
1490
- message?: string;
1491
1596
  found?: unknown;
1492
1597
  property?: string;
1493
1598
  expected?: string;
1494
1599
  };
1495
1600
  };
1601
+ error: never;
1496
1602
  };
1497
1603
  };
1498
1604
  } & {
@@ -1505,6 +1611,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1505
1611
  response: {
1506
1612
  200: Response;
1507
1613
  };
1614
+ error: never;
1508
1615
  };
1509
1616
  };
1510
1617
  } & {
@@ -1520,14 +1627,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1520
1627
  200: Response;
1521
1628
  422: {
1522
1629
  type: "validation";
1630
+ title: "Validation Error";
1631
+ status: 422;
1632
+ detail?: string;
1523
1633
  on: string;
1524
- summary?: string;
1525
- message?: string;
1526
1634
  found?: unknown;
1527
1635
  property?: string;
1528
1636
  expected?: string;
1529
1637
  };
1530
1638
  };
1639
+ error: never;
1531
1640
  };
1532
1641
  };
1533
1642
  } & {
@@ -1543,14 +1652,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1543
1652
  200: Response;
1544
1653
  422: {
1545
1654
  type: "validation";
1655
+ title: "Validation Error";
1656
+ status: 422;
1657
+ detail?: string;
1546
1658
  on: string;
1547
- summary?: string;
1548
- message?: string;
1549
1659
  found?: unknown;
1550
1660
  property?: string;
1551
1661
  expected?: string;
1552
1662
  };
1553
1663
  };
1664
+ error: never;
1554
1665
  };
1555
1666
  };
1556
1667
  } & {
@@ -1566,14 +1677,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1566
1677
  200: Response;
1567
1678
  422: {
1568
1679
  type: "validation";
1680
+ title: "Validation Error";
1681
+ status: 422;
1682
+ detail?: string;
1569
1683
  on: string;
1570
- summary?: string;
1571
- message?: string;
1572
1684
  found?: unknown;
1573
1685
  property?: string;
1574
1686
  expected?: string;
1575
1687
  };
1576
1688
  };
1689
+ error: never;
1577
1690
  };
1578
1691
  };
1579
1692
  } & {
@@ -1589,14 +1702,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1589
1702
  200: Response;
1590
1703
  422: {
1591
1704
  type: "validation";
1705
+ title: "Validation Error";
1706
+ status: 422;
1707
+ detail?: string;
1592
1708
  on: string;
1593
- summary?: string;
1594
- message?: string;
1595
1709
  found?: unknown;
1596
1710
  property?: string;
1597
1711
  expected?: string;
1598
1712
  };
1599
1713
  };
1714
+ error: never;
1600
1715
  };
1601
1716
  };
1602
1717
  } & {
@@ -1612,14 +1727,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1612
1727
  200: Response;
1613
1728
  422: {
1614
1729
  type: "validation";
1730
+ title: "Validation Error";
1731
+ status: 422;
1732
+ detail?: string;
1615
1733
  on: string;
1616
- summary?: string;
1617
- message?: string;
1618
1734
  found?: unknown;
1619
1735
  property?: string;
1620
1736
  expected?: string;
1621
1737
  };
1622
1738
  };
1739
+ error: never;
1623
1740
  };
1624
1741
  };
1625
1742
  } & {
@@ -1632,6 +1749,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1632
1749
  response: {
1633
1750
  200: Response;
1634
1751
  };
1752
+ error: never;
1635
1753
  };
1636
1754
  };
1637
1755
  } & {
@@ -1647,14 +1765,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1647
1765
  200: Response;
1648
1766
  422: {
1649
1767
  type: "validation";
1768
+ title: "Validation Error";
1769
+ status: 422;
1770
+ detail?: string;
1650
1771
  on: string;
1651
- summary?: string;
1652
- message?: string;
1653
1772
  found?: unknown;
1654
1773
  property?: string;
1655
1774
  expected?: string;
1656
1775
  };
1657
1776
  };
1777
+ error: never;
1658
1778
  };
1659
1779
  };
1660
1780
  } & {
@@ -1667,6 +1787,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1667
1787
  response: {
1668
1788
  200: Response;
1669
1789
  };
1790
+ error: never;
1670
1791
  };
1671
1792
  };
1672
1793
  } & {
@@ -1682,14 +1803,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1682
1803
  200: Response;
1683
1804
  422: {
1684
1805
  type: "validation";
1806
+ title: "Validation Error";
1807
+ status: 422;
1808
+ detail?: string;
1685
1809
  on: string;
1686
- summary?: string;
1687
- message?: string;
1688
1810
  found?: unknown;
1689
1811
  property?: string;
1690
1812
  expected?: string;
1691
1813
  };
1692
1814
  };
1815
+ error: never;
1693
1816
  };
1694
1817
  };
1695
1818
  }))) & ({} | {
@@ -1708,14 +1831,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1708
1831
  200: Response;
1709
1832
  422: {
1710
1833
  type: "validation";
1834
+ title: "Validation Error";
1835
+ status: 422;
1836
+ detail?: string;
1711
1837
  on: string;
1712
- summary?: string;
1713
- message?: string;
1714
1838
  found?: unknown;
1715
1839
  property?: string;
1716
1840
  expected?: string;
1717
1841
  };
1718
1842
  };
1843
+ error: never;
1719
1844
  };
1720
1845
  };
1721
1846
  })) & ({} | ({
@@ -1747,14 +1872,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1747
1872
  200: Response;
1748
1873
  422: {
1749
1874
  type: "validation";
1875
+ title: "Validation Error";
1876
+ status: 422;
1877
+ detail?: string;
1750
1878
  on: string;
1751
- summary?: string;
1752
- message?: string;
1753
1879
  found?: unknown;
1754
1880
  property?: string;
1755
1881
  expected?: string;
1756
1882
  };
1757
1883
  };
1884
+ error: never;
1758
1885
  };
1759
1886
  };
1760
1887
  } & {
@@ -1788,14 +1915,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1788
1915
  200: Response;
1789
1916
  422: {
1790
1917
  type: "validation";
1918
+ title: "Validation Error";
1919
+ status: 422;
1920
+ detail?: string;
1791
1921
  on: string;
1792
- summary?: string;
1793
- message?: string;
1794
1922
  found?: unknown;
1795
1923
  property?: string;
1796
1924
  expected?: string;
1797
1925
  };
1798
1926
  };
1927
+ error: never;
1799
1928
  };
1800
1929
  };
1801
1930
  } & {
@@ -1827,14 +1956,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1827
1956
  200: Response;
1828
1957
  422: {
1829
1958
  type: "validation";
1959
+ title: "Validation Error";
1960
+ status: 422;
1961
+ detail?: string;
1830
1962
  on: string;
1831
- summary?: string;
1832
- message?: string;
1833
1963
  found?: unknown;
1834
1964
  property?: string;
1835
1965
  expected?: string;
1836
1966
  };
1837
1967
  };
1968
+ error: never;
1838
1969
  };
1839
1970
  };
1840
1971
  } & {
@@ -1855,14 +1986,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1855
1986
  200: Response;
1856
1987
  422: {
1857
1988
  type: "validation";
1989
+ title: "Validation Error";
1990
+ status: 422;
1991
+ detail?: string;
1858
1992
  on: string;
1859
- summary?: string;
1860
- message?: string;
1861
1993
  found?: unknown;
1862
1994
  property?: string;
1863
1995
  expected?: string;
1864
1996
  };
1865
1997
  };
1998
+ error: never;
1866
1999
  };
1867
2000
  };
1868
2001
  } & {
@@ -1883,14 +2016,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1883
2016
  200: Response;
1884
2017
  422: {
1885
2018
  type: "validation";
2019
+ title: "Validation Error";
2020
+ status: 422;
2021
+ detail?: string;
1886
2022
  on: string;
1887
- summary?: string;
1888
- message?: string;
1889
2023
  found?: unknown;
1890
2024
  property?: string;
1891
2025
  expected?: string;
1892
2026
  };
1893
2027
  };
2028
+ error: never;
1894
2029
  };
1895
2030
  };
1896
2031
  } & {
@@ -1912,14 +2047,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1912
2047
  200: Response;
1913
2048
  422: {
1914
2049
  type: "validation";
2050
+ title: "Validation Error";
2051
+ status: 422;
2052
+ detail?: string;
1915
2053
  on: string;
1916
- summary?: string;
1917
- message?: string;
1918
2054
  found?: unknown;
1919
2055
  property?: string;
1920
2056
  expected?: string;
1921
2057
  };
1922
2058
  };
2059
+ error: never;
1923
2060
  };
1924
2061
  };
1925
2062
  } & {
@@ -1939,14 +2076,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1939
2076
  200: Response;
1940
2077
  422: {
1941
2078
  type: "validation";
2079
+ title: "Validation Error";
2080
+ status: 422;
2081
+ detail?: string;
1942
2082
  on: string;
1943
- summary?: string;
1944
- message?: string;
1945
2083
  found?: unknown;
1946
2084
  property?: string;
1947
2085
  expected?: string;
1948
2086
  };
1949
2087
  };
2088
+ error: never;
1950
2089
  };
1951
2090
  };
1952
2091
  } & {
@@ -1963,14 +2102,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1963
2102
  200: Response;
1964
2103
  422: {
1965
2104
  type: "validation";
2105
+ title: "Validation Error";
2106
+ status: 422;
2107
+ detail?: string;
1966
2108
  on: string;
1967
- summary?: string;
1968
- message?: string;
1969
2109
  found?: unknown;
1970
2110
  property?: string;
1971
2111
  expected?: string;
1972
2112
  };
1973
2113
  };
2114
+ error: never;
1974
2115
  };
1975
2116
  };
1976
2117
  } & {
@@ -1989,14 +2130,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
1989
2130
  200: Response;
1990
2131
  422: {
1991
2132
  type: "validation";
2133
+ title: "Validation Error";
2134
+ status: 422;
2135
+ detail?: string;
1992
2136
  on: string;
1993
- summary?: string;
1994
- message?: string;
1995
2137
  found?: unknown;
1996
2138
  property?: string;
1997
2139
  expected?: string;
1998
2140
  };
1999
2141
  };
2142
+ error: never;
2000
2143
  };
2001
2144
  };
2002
2145
  } & {
@@ -2015,14 +2158,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2015
2158
  200: Response;
2016
2159
  422: {
2017
2160
  type: "validation";
2161
+ title: "Validation Error";
2162
+ status: 422;
2163
+ detail?: string;
2018
2164
  on: string;
2019
- summary?: string;
2020
- message?: string;
2021
2165
  found?: unknown;
2022
2166
  property?: string;
2023
2167
  expected?: string;
2024
2168
  };
2025
2169
  };
2170
+ error: never;
2026
2171
  };
2027
2172
  };
2028
2173
  } & {
@@ -2047,14 +2192,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2047
2192
  200: Response;
2048
2193
  422: {
2049
2194
  type: "validation";
2195
+ title: "Validation Error";
2196
+ status: 422;
2197
+ detail?: string;
2050
2198
  on: string;
2051
- summary?: string;
2052
- message?: string;
2053
2199
  found?: unknown;
2054
2200
  property?: string;
2055
2201
  expected?: string;
2056
2202
  };
2057
2203
  };
2204
+ error: never;
2058
2205
  };
2059
2206
  };
2060
2207
  } & {
@@ -2073,14 +2220,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2073
2220
  200: Response;
2074
2221
  422: {
2075
2222
  type: "validation";
2223
+ title: "Validation Error";
2224
+ status: 422;
2225
+ detail?: string;
2076
2226
  on: string;
2077
- summary?: string;
2078
- message?: string;
2079
2227
  found?: unknown;
2080
2228
  property?: string;
2081
2229
  expected?: string;
2082
2230
  };
2083
2231
  };
2232
+ error: never;
2084
2233
  };
2085
2234
  };
2086
2235
  };
@@ -2109,14 +2258,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2109
2258
  200: Response;
2110
2259
  422: {
2111
2260
  type: "validation";
2261
+ title: "Validation Error";
2262
+ status: 422;
2263
+ detail?: string;
2112
2264
  on: string;
2113
- summary?: string;
2114
- message?: string;
2115
2265
  found?: unknown;
2116
2266
  property?: string;
2117
2267
  expected?: string;
2118
2268
  };
2119
2269
  };
2270
+ error: never;
2120
2271
  };
2121
2272
  };
2122
2273
  };
@@ -2136,14 +2287,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2136
2287
  200: Response;
2137
2288
  422: {
2138
2289
  type: "validation";
2290
+ title: "Validation Error";
2291
+ status: 422;
2292
+ detail?: string;
2139
2293
  on: string;
2140
- summary?: string;
2141
- message?: string;
2142
2294
  found?: unknown;
2143
2295
  property?: string;
2144
2296
  expected?: string;
2145
2297
  };
2146
2298
  };
2299
+ error: never;
2147
2300
  };
2148
2301
  };
2149
2302
  };
@@ -2160,14 +2313,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2160
2313
  200: Response;
2161
2314
  422: {
2162
2315
  type: "validation";
2316
+ title: "Validation Error";
2317
+ status: 422;
2318
+ detail?: string;
2163
2319
  on: string;
2164
- summary?: string;
2165
- message?: string;
2166
2320
  found?: unknown;
2167
2321
  property?: string;
2168
2322
  expected?: string;
2169
2323
  };
2170
2324
  };
2325
+ error: never;
2171
2326
  };
2172
2327
  };
2173
2328
  } & {
@@ -2185,14 +2340,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2185
2340
  200: Response;
2186
2341
  422: {
2187
2342
  type: "validation";
2343
+ title: "Validation Error";
2344
+ status: 422;
2345
+ detail?: string;
2188
2346
  on: string;
2189
- summary?: string;
2190
- message?: string;
2191
2347
  found?: unknown;
2192
2348
  property?: string;
2193
2349
  expected?: string;
2194
2350
  };
2195
2351
  };
2352
+ error: never;
2196
2353
  };
2197
2354
  };
2198
2355
  } & {
@@ -2215,6 +2372,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2215
2372
  }[];
2216
2373
  };
2217
2374
  };
2375
+ error: never;
2218
2376
  };
2219
2377
  };
2220
2378
  } & {
@@ -2228,6 +2386,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2228
2386
  response: {
2229
2387
  200: Record<string, unknown>;
2230
2388
  };
2389
+ error: never;
2231
2390
  };
2232
2391
  };
2233
2392
  };
@@ -2242,6 +2401,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2242
2401
  response: {
2243
2402
  200: Record<string, unknown>;
2244
2403
  };
2404
+ error: never;
2245
2405
  };
2246
2406
  };
2247
2407
  };
@@ -2262,21 +2422,23 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2262
2422
  };
2263
2423
  422: {
2264
2424
  type: "validation";
2425
+ title: "Validation Error";
2426
+ status: 422;
2427
+ detail?: string;
2265
2428
  on: string;
2266
- summary?: string;
2267
- message?: string;
2268
2429
  found?: unknown;
2269
2430
  property?: string;
2270
2431
  expected?: string;
2271
2432
  };
2272
2433
  };
2434
+ error: never;
2273
2435
  };
2274
2436
  };
2275
2437
  } & {
2276
2438
  [x: string]: {
2277
2439
  post: {
2278
2440
  body: {
2279
- metadata?: {} | undefined;
2441
+ metadata?: Record<string, unknown> | undefined;
2280
2442
  name: string;
2281
2443
  };
2282
2444
  params: {};
@@ -2290,14 +2452,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2290
2452
  };
2291
2453
  422: {
2292
2454
  type: "validation";
2455
+ title: "Validation Error";
2456
+ status: 422;
2457
+ detail?: string;
2293
2458
  on: string;
2294
- summary?: string;
2295
- message?: string;
2296
2459
  found?: unknown;
2297
2460
  property?: string;
2298
2461
  expected?: string;
2299
2462
  };
2300
2463
  };
2464
+ error: never;
2301
2465
  };
2302
2466
  };
2303
2467
  } & {
@@ -2323,14 +2487,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2323
2487
  };
2324
2488
  422: {
2325
2489
  type: "validation";
2490
+ title: "Validation Error";
2491
+ status: 422;
2492
+ detail?: string;
2326
2493
  on: string;
2327
- summary?: string;
2328
- message?: string;
2329
2494
  found?: unknown;
2330
2495
  property?: string;
2331
2496
  expected?: string;
2332
2497
  };
2333
2498
  };
2499
+ error: never;
2334
2500
  };
2335
2501
  };
2336
2502
  };
@@ -2360,14 +2526,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2360
2526
  };
2361
2527
  422: {
2362
2528
  type: "validation";
2529
+ title: "Validation Error";
2530
+ status: 422;
2531
+ detail?: string;
2363
2532
  on: string;
2364
- summary?: string;
2365
- message?: string;
2366
2533
  found?: unknown;
2367
2534
  property?: string;
2368
2535
  expected?: string;
2369
2536
  };
2370
2537
  };
2538
+ error: never;
2371
2539
  };
2372
2540
  };
2373
2541
  };
@@ -2394,14 +2562,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2394
2562
  };
2395
2563
  422: {
2396
2564
  type: "validation";
2565
+ title: "Validation Error";
2566
+ status: 422;
2567
+ detail?: string;
2397
2568
  on: string;
2398
- summary?: string;
2399
- message?: string;
2400
2569
  found?: unknown;
2401
2570
  property?: string;
2402
2571
  expected?: string;
2403
2572
  };
2404
2573
  };
2574
+ error: never;
2405
2575
  };
2406
2576
  };
2407
2577
  };
@@ -2427,14 +2597,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2427
2597
  };
2428
2598
  422: {
2429
2599
  type: "validation";
2600
+ title: "Validation Error";
2601
+ status: 422;
2602
+ detail?: string;
2430
2603
  on: string;
2431
- summary?: string;
2432
- message?: string;
2433
2604
  found?: unknown;
2434
2605
  property?: string;
2435
2606
  expected?: string;
2436
2607
  };
2437
2608
  };
2609
+ error: never;
2438
2610
  };
2439
2611
  };
2440
2612
  };
@@ -2458,14 +2630,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2458
2630
  };
2459
2631
  422: {
2460
2632
  type: "validation";
2633
+ title: "Validation Error";
2634
+ status: 422;
2635
+ detail?: string;
2461
2636
  on: string;
2462
- summary?: string;
2463
- message?: string;
2464
2637
  found?: unknown;
2465
2638
  property?: string;
2466
2639
  expected?: string;
2467
2640
  };
2468
2641
  };
2642
+ error: never;
2469
2643
  };
2470
2644
  };
2471
2645
  };
@@ -2491,14 +2665,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2491
2665
  };
2492
2666
  422: {
2493
2667
  type: "validation";
2668
+ title: "Validation Error";
2669
+ status: 422;
2670
+ detail?: string;
2494
2671
  on: string;
2495
- summary?: string;
2496
- message?: string;
2497
2672
  found?: unknown;
2498
2673
  property?: string;
2499
2674
  expected?: string;
2500
2675
  };
2501
2676
  };
2677
+ error: never;
2502
2678
  };
2503
2679
  };
2504
2680
  };
@@ -2522,14 +2698,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2522
2698
  };
2523
2699
  422: {
2524
2700
  type: "validation";
2701
+ title: "Validation Error";
2702
+ status: 422;
2703
+ detail?: string;
2525
2704
  on: string;
2526
- summary?: string;
2527
- message?: string;
2528
2705
  found?: unknown;
2529
2706
  property?: string;
2530
2707
  expected?: string;
2531
2708
  };
2532
2709
  };
2710
+ error: never;
2533
2711
  };
2534
2712
  };
2535
2713
  };
@@ -2557,20 +2735,22 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2557
2735
  };
2558
2736
  422: {
2559
2737
  type: "validation";
2738
+ title: "Validation Error";
2739
+ status: 422;
2740
+ detail?: string;
2560
2741
  on: string;
2561
- summary?: string;
2562
- message?: string;
2563
2742
  found?: unknown;
2564
2743
  property?: string;
2565
2744
  expected?: string;
2566
2745
  };
2567
2746
  };
2747
+ error: never;
2568
2748
  };
2569
2749
  };
2570
2750
  };
2571
2751
  };
2572
2752
  };
2573
- }))) & ({} | ({
2753
+ })))) & ((((({} | ({
2574
2754
  [x: string]: {
2575
2755
  session: {
2576
2756
  get: {
@@ -2601,6 +2781,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2601
2781
  } | undefined;
2602
2782
  };
2603
2783
  };
2784
+ error: never;
2604
2785
  };
2605
2786
  };
2606
2787
  };
@@ -2628,14 +2809,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2628
2809
  };
2629
2810
  422: {
2630
2811
  type: "validation";
2812
+ title: "Validation Error";
2813
+ status: 422;
2814
+ detail?: string;
2631
2815
  on: string;
2632
- summary?: string;
2633
- message?: string;
2634
2816
  found?: unknown;
2635
2817
  property?: string;
2636
2818
  expected?: string;
2637
2819
  };
2638
2820
  };
2821
+ error: never;
2639
2822
  };
2640
2823
  };
2641
2824
  };
@@ -2665,14 +2848,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2665
2848
  };
2666
2849
  422: {
2667
2850
  type: "validation";
2851
+ title: "Validation Error";
2852
+ status: 422;
2853
+ detail?: string;
2668
2854
  on: string;
2669
- summary?: string;
2670
- message?: string;
2671
2855
  found?: unknown;
2672
2856
  property?: string;
2673
2857
  expected?: string;
2674
2858
  };
2675
2859
  };
2860
+ error: never;
2676
2861
  };
2677
2862
  };
2678
2863
  };
@@ -2696,11 +2881,12 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2696
2881
  readonly tokenId: string;
2697
2882
  };
2698
2883
  };
2884
+ error: never;
2699
2885
  };
2700
2886
  };
2701
2887
  };
2702
2888
  };
2703
- }))) & ({} | ({
2889
+ })) & ({} | ({
2704
2890
  [x: string]: {
2705
2891
  register: {
2706
2892
  options: {
@@ -2716,14 +2902,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2716
2902
  };
2717
2903
  422: {
2718
2904
  type: "validation";
2905
+ title: "Validation Error";
2906
+ status: 422;
2907
+ detail?: string;
2719
2908
  on: string;
2720
- summary?: string;
2721
- message?: string;
2722
2909
  found?: unknown;
2723
2910
  property?: string;
2724
2911
  expected?: string;
2725
2912
  };
2726
2913
  };
2914
+ error: never;
2727
2915
  };
2728
2916
  };
2729
2917
  };
@@ -2733,7 +2921,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2733
2921
  register: {
2734
2922
  verify: {
2735
2923
  post: {
2736
- body: {};
2924
+ body: object;
2737
2925
  params: {};
2738
2926
  query: unknown;
2739
2927
  headers: unknown;
@@ -2746,14 +2934,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2746
2934
  };
2747
2935
  422: {
2748
2936
  type: "validation";
2937
+ title: "Validation Error";
2938
+ status: 422;
2939
+ detail?: string;
2749
2940
  on: string;
2750
- summary?: string;
2751
- message?: string;
2752
2941
  found?: unknown;
2753
2942
  property?: string;
2754
2943
  expected?: string;
2755
2944
  };
2756
2945
  };
2946
+ error: never;
2757
2947
  };
2758
2948
  };
2759
2949
  };
@@ -2773,14 +2963,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2773
2963
  };
2774
2964
  422: {
2775
2965
  type: "validation";
2966
+ title: "Validation Error";
2967
+ status: 422;
2968
+ detail?: string;
2776
2969
  on: string;
2777
- summary?: string;
2778
- message?: string;
2779
2970
  found?: unknown;
2780
2971
  property?: string;
2781
2972
  expected?: string;
2782
2973
  };
2783
2974
  };
2975
+ error: never;
2784
2976
  };
2785
2977
  };
2786
2978
  };
@@ -2804,14 +2996,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2804
2996
  };
2805
2997
  422: {
2806
2998
  type: "validation";
2999
+ title: "Validation Error";
3000
+ status: 422;
3001
+ detail?: string;
2807
3002
  on: string;
2808
- summary?: string;
2809
- message?: string;
2810
3003
  found?: unknown;
2811
3004
  property?: string;
2812
3005
  expected?: string;
2813
3006
  };
2814
3007
  };
3008
+ error: never;
2815
3009
  };
2816
3010
  };
2817
3011
  };
@@ -2831,14 +3025,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2831
3025
  };
2832
3026
  422: {
2833
3027
  type: "validation";
3028
+ title: "Validation Error";
3029
+ status: 422;
3030
+ detail?: string;
2834
3031
  on: string;
2835
- summary?: string;
2836
- message?: string;
2837
3032
  found?: unknown;
2838
3033
  property?: string;
2839
3034
  expected?: string;
2840
3035
  };
2841
3036
  };
3037
+ error: never;
2842
3038
  };
2843
3039
  };
2844
3040
  };
@@ -2856,14 +3052,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2856
3052
  };
2857
3053
  422: {
2858
3054
  type: "validation";
3055
+ title: "Validation Error";
3056
+ status: 422;
3057
+ detail?: string;
2859
3058
  on: string;
2860
- summary?: string;
2861
- message?: string;
2862
3059
  found?: unknown;
2863
3060
  property?: string;
2864
3061
  expected?: string;
2865
3062
  };
2866
3063
  };
3064
+ error: never;
2867
3065
  };
2868
3066
  };
2869
3067
  }))) & ({} | ({
@@ -2878,14 +3076,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2878
3076
  200: Response;
2879
3077
  422: {
2880
3078
  type: "validation";
3079
+ title: "Validation Error";
3080
+ status: 422;
3081
+ detail?: string;
2881
3082
  on: string;
2882
- summary?: string;
2883
- message?: string;
2884
3083
  found?: unknown;
2885
3084
  property?: string;
2886
3085
  expected?: string;
2887
3086
  };
2888
3087
  };
3088
+ error: never;
2889
3089
  };
2890
3090
  };
2891
3091
  };
@@ -2901,14 +3101,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2901
3101
  200: Response;
2902
3102
  422: {
2903
3103
  type: "validation";
3104
+ title: "Validation Error";
3105
+ status: 422;
3106
+ detail?: string;
2904
3107
  on: string;
2905
- summary?: string;
2906
- message?: string;
2907
3108
  found?: unknown;
2908
3109
  property?: string;
2909
3110
  expected?: string;
2910
3111
  };
2911
3112
  };
3113
+ error: never;
2912
3114
  };
2913
3115
  };
2914
3116
  };
@@ -2924,14 +3126,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2924
3126
  200: Response;
2925
3127
  422: {
2926
3128
  type: "validation";
3129
+ title: "Validation Error";
3130
+ status: 422;
3131
+ detail?: string;
2927
3132
  on: string;
2928
- summary?: string;
2929
- message?: string;
2930
3133
  found?: unknown;
2931
3134
  property?: string;
2932
3135
  expected?: string;
2933
3136
  };
2934
3137
  };
3138
+ error: never;
2935
3139
  };
2936
3140
  };
2937
3141
  };
@@ -2949,14 +3153,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2949
3153
  200: Response;
2950
3154
  422: {
2951
3155
  type: "validation";
3156
+ title: "Validation Error";
3157
+ status: 422;
3158
+ detail?: string;
2952
3159
  on: string;
2953
- summary?: string;
2954
- message?: string;
2955
3160
  found?: unknown;
2956
3161
  property?: string;
2957
3162
  expected?: string;
2958
3163
  };
2959
3164
  };
3165
+ error: never;
2960
3166
  };
2961
3167
  };
2962
3168
  };
@@ -2974,14 +3180,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2974
3180
  200: Response;
2975
3181
  422: {
2976
3182
  type: "validation";
3183
+ title: "Validation Error";
3184
+ status: 422;
3185
+ detail?: string;
2977
3186
  on: string;
2978
- summary?: string;
2979
- message?: string;
2980
3187
  found?: unknown;
2981
3188
  property?: string;
2982
3189
  expected?: string;
2983
3190
  };
2984
3191
  };
3192
+ error: never;
2985
3193
  };
2986
3194
  };
2987
3195
  };
@@ -2999,14 +3207,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
2999
3207
  200: Response;
3000
3208
  422: {
3001
3209
  type: "validation";
3210
+ title: "Validation Error";
3211
+ status: 422;
3212
+ detail?: string;
3002
3213
  on: string;
3003
- summary?: string;
3004
- message?: string;
3005
3214
  found?: unknown;
3006
3215
  property?: string;
3007
3216
  expected?: string;
3008
3217
  };
3009
3218
  };
3219
+ error: never;
3010
3220
  };
3011
3221
  };
3012
3222
  };
@@ -3024,14 +3234,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3024
3234
  200: Response;
3025
3235
  422: {
3026
3236
  type: "validation";
3237
+ title: "Validation Error";
3238
+ status: 422;
3239
+ detail?: string;
3027
3240
  on: string;
3028
- summary?: string;
3029
- message?: string;
3030
3241
  found?: unknown;
3031
3242
  property?: string;
3032
3243
  expected?: string;
3033
3244
  };
3034
3245
  };
3246
+ error: never;
3035
3247
  };
3036
3248
  };
3037
3249
  };
@@ -3053,14 +3265,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3053
3265
  200: Response;
3054
3266
  422: {
3055
3267
  type: "validation";
3268
+ title: "Validation Error";
3269
+ status: 422;
3270
+ detail?: string;
3056
3271
  on: string;
3057
- summary?: string;
3058
- message?: string;
3059
3272
  found?: unknown;
3060
3273
  property?: string;
3061
3274
  expected?: string;
3062
3275
  };
3063
3276
  };
3277
+ error: never;
3064
3278
  };
3065
3279
  };
3066
3280
  };
@@ -3083,14 +3297,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3083
3297
  200: Response;
3084
3298
  422: {
3085
3299
  type: "validation";
3300
+ title: "Validation Error";
3301
+ status: 422;
3302
+ detail?: string;
3086
3303
  on: string;
3087
- summary?: string;
3088
- message?: string;
3089
3304
  found?: unknown;
3090
3305
  property?: string;
3091
3306
  expected?: string;
3092
3307
  };
3093
3308
  };
3309
+ error: never;
3094
3310
  };
3095
3311
  };
3096
3312
  };
@@ -3112,14 +3328,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3112
3328
  200: Response;
3113
3329
  422: {
3114
3330
  type: "validation";
3331
+ title: "Validation Error";
3332
+ status: 422;
3333
+ detail?: string;
3115
3334
  on: string;
3116
- summary?: string;
3117
- message?: string;
3118
3335
  found?: unknown;
3119
3336
  property?: string;
3120
3337
  expected?: string;
3121
3338
  };
3122
3339
  };
3340
+ error: never;
3123
3341
  };
3124
3342
  };
3125
3343
  };
@@ -3141,14 +3359,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3141
3359
  200: Response;
3142
3360
  422: {
3143
3361
  type: "validation";
3362
+ title: "Validation Error";
3363
+ status: 422;
3364
+ detail?: string;
3144
3365
  on: string;
3145
- summary?: string;
3146
- message?: string;
3147
3366
  found?: unknown;
3148
3367
  property?: string;
3149
3368
  expected?: string;
3150
3369
  };
3151
3370
  };
3371
+ error: never;
3152
3372
  };
3153
3373
  };
3154
3374
  };
@@ -3167,14 +3387,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3167
3387
  200: Response;
3168
3388
  422: {
3169
3389
  type: "validation";
3390
+ title: "Validation Error";
3391
+ status: 422;
3392
+ detail?: string;
3170
3393
  on: string;
3171
- summary?: string;
3172
- message?: string;
3173
3394
  found?: unknown;
3174
3395
  property?: string;
3175
3396
  expected?: string;
3176
3397
  };
3177
3398
  };
3399
+ error: never;
3178
3400
  };
3179
3401
  };
3180
3402
  };
@@ -3196,14 +3418,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3196
3418
  200: Response;
3197
3419
  422: {
3198
3420
  type: "validation";
3421
+ title: "Validation Error";
3422
+ status: 422;
3423
+ detail?: string;
3199
3424
  on: string;
3200
- summary?: string;
3201
- message?: string;
3202
3425
  found?: unknown;
3203
3426
  property?: string;
3204
3427
  expected?: string;
3205
3428
  };
3206
3429
  };
3430
+ error: never;
3207
3431
  };
3208
3432
  };
3209
3433
  };
@@ -3227,14 +3451,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3227
3451
  200: Response;
3228
3452
  422: {
3229
3453
  type: "validation";
3454
+ title: "Validation Error";
3455
+ status: 422;
3456
+ detail?: string;
3230
3457
  on: string;
3231
- summary?: string;
3232
- message?: string;
3233
3458
  found?: unknown;
3234
3459
  property?: string;
3235
3460
  expected?: string;
3236
3461
  };
3237
3462
  };
3463
+ error: never;
3238
3464
  };
3239
3465
  };
3240
3466
  };
@@ -3252,14 +3478,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3252
3478
  200: Response;
3253
3479
  422: {
3254
3480
  type: "validation";
3481
+ title: "Validation Error";
3482
+ status: 422;
3483
+ detail?: string;
3255
3484
  on: string;
3256
- summary?: string;
3257
- message?: string;
3258
3485
  found?: unknown;
3259
3486
  property?: string;
3260
3487
  expected?: string;
3261
3488
  };
3262
3489
  };
3490
+ error: never;
3263
3491
  };
3264
3492
  };
3265
3493
  };
@@ -3277,14 +3505,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3277
3505
  200: Response;
3278
3506
  422: {
3279
3507
  type: "validation";
3508
+ title: "Validation Error";
3509
+ status: 422;
3510
+ detail?: string;
3280
3511
  on: string;
3281
- summary?: string;
3282
- message?: string;
3283
3512
  found?: unknown;
3284
3513
  property?: string;
3285
3514
  expected?: string;
3286
3515
  };
3287
3516
  };
3517
+ error: never;
3288
3518
  };
3289
3519
  };
3290
3520
  };
@@ -3300,14 +3530,16 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3300
3530
  200: Response;
3301
3531
  422: {
3302
3532
  type: "validation";
3533
+ title: "Validation Error";
3534
+ status: 422;
3535
+ detail?: string;
3303
3536
  on: string;
3304
- summary?: string;
3305
- message?: string;
3306
3537
  found?: unknown;
3307
3538
  property?: string;
3308
3539
  expected?: string;
3309
3540
  };
3310
3541
  };
3542
+ error: never;
3311
3543
  };
3312
3544
  };
3313
3545
  };
@@ -3328,6 +3560,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3328
3560
  bearer_methods_supported: string[];
3329
3561
  };
3330
3562
  };
3563
+ error: never;
3331
3564
  };
3332
3565
  };
3333
3566
  } & {
@@ -3340,6 +3573,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3340
3573
  response: {
3341
3574
  200: Response;
3342
3575
  };
3576
+ error: never;
3343
3577
  };
3344
3578
  };
3345
3579
  } & {
@@ -3352,6 +3586,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3352
3586
  response: {
3353
3587
  200: Response;
3354
3588
  };
3589
+ error: never;
3355
3590
  };
3356
3591
  };
3357
3592
  } & {
@@ -3364,6 +3599,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3364
3599
  response: {
3365
3600
  200: Response;
3366
3601
  };
3602
+ error: never;
3367
3603
  };
3368
3604
  };
3369
3605
  } & {
@@ -3376,6 +3612,7 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3376
3612
  response: {
3377
3613
  200: Response;
3378
3614
  };
3615
+ error: never;
3379
3616
  };
3380
3617
  };
3381
3618
  } & {
@@ -3388,32 +3625,15 @@ export declare const createAuthApplications: <UserType>(configuration: AuthConfi
3388
3625
  response: {
3389
3626
  200: Response;
3390
3627
  };
3628
+ error: never;
3391
3629
  };
3392
3630
  };
3393
- })), {
3394
- derive: {};
3395
- resolve: {};
3396
- schema: {};
3397
- standaloneSchema: {};
3398
- response: {};
3399
- }, {
3400
- derive: {};
3401
- resolve: {};
3402
- schema: {};
3403
- standaloneSchema: {};
3404
- response: {};
3405
- } & {
3406
- derive: {};
3407
- resolve: {};
3408
- schema: {};
3409
- standaloneSchema: {};
3410
- response: {};
3411
- } & {
3631
+ }))), import("elysia/types").DefaultEphemeral, {
3412
3632
  derive: {};
3413
- resolve: {};
3414
3633
  schema: {};
3415
- standaloneSchema: {};
3634
+ schemas: {};
3416
3635
  response: {};
3636
+ error: [];
3417
3637
  }>;
3418
3638
  }>;
3419
3639
  export * from './actions';