npm - @marcoappio/marco-config - Versions diffs - 7.0.0 → 7.1.0 - Mend

@marcoappio/marco-config 7.0.0 → 7.1.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 (34) hide show

package/dist/sdk/endpoints/index.d.ts CHANGED Viewed

@@ -115,6 +115,128 @@ export declare const endpoints: {
     };
     public: {
         auth: {
+            browser: {
+                deleteSession: EndpointConfig<"/v1/pb/auth/browser/session", GenericSchema | undefined, import("valibot").StrictObjectSchema<{
+                    readonly sessionGeneration: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
+                }, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+                    readonly data: import("valibot").StrictObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly issues: import("valibot").ObjectSchema<{
+                            readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                            readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        }, undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<400, undefined>;
+                }, undefined>, import("valibot").StrictObjectSchema<{
+                    readonly status: import("valibot").LiteralSchema<204, undefined>;
+                }, undefined>], undefined>>;
+                refreshAuth: EndpointConfig<"/v1/pb/auth/browser/refresh", GenericSchema | undefined, import("valibot").StrictObjectSchema<{
+                    readonly sessionGeneration: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
+                }, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+                    readonly data: import("valibot").StrictObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly issues: import("valibot").ObjectSchema<{
+                            readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                            readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        }, undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<400, undefined>;
+                }, undefined>, import("valibot").StrictObjectSchema<{
+                    readonly data: import("valibot").StrictObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<401, undefined>;
+                }, undefined>, import("valibot").StrictObjectSchema<{
+                    readonly data: import("valibot").StrictObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<502, undefined>;
+                }, undefined>, import("valibot").StrictObjectSchema<{
+                    readonly data: import("valibot").StrictObjectSchema<{
+                        accessToken: import("valibot").StringSchema<undefined>;
+                        user: import("valibot").ObjectSchema<{
+                            readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
+                            readonly emailVerified: import("valibot").BooleanSchema<undefined>;
+                            readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly profilePictureUrl: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        }, undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<200, undefined>;
+                }, undefined>], undefined>>;
+                verifyAuthCode: EndpointConfig<"/v1/pb/auth/browser/verify-code", import("valibot").ObjectSchema<{
+                    readonly authType: import("valibot").LiteralSchema<"CODE", undefined>;
+                    readonly code: import("valibot").StringSchema<undefined>;
+                    readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
+                }, undefined>, import("valibot").StrictObjectSchema<{
+                    readonly sessionGeneration: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
+                }, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+                    readonly data: import("valibot").StrictObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                        readonly issues: import("valibot").ObjectSchema<{
+                            readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                            readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        }, undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<400, undefined>;
+                }, undefined>, import("valibot").StrictObjectSchema<{
+                    readonly data: import("valibot").StrictObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<401, undefined>;
+                }, undefined>, import("valibot").StrictObjectSchema<{
+                    readonly data: import("valibot").StrictObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTH_CODE_INVALID", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<401, undefined>;
+                }, undefined>, import("valibot").StrictObjectSchema<{
+                    readonly data: import("valibot").StrictObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<401, undefined>;
+                }, undefined>, import("valibot").StrictObjectSchema<{
+                    readonly data: import("valibot").StrictObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<401, undefined>;
+                }, undefined>, import("valibot").StrictObjectSchema<{
+                    readonly data: import("valibot").StrictObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<502, undefined>;
+                }, undefined>, import("valibot").StrictObjectSchema<{
+                    readonly data: import("valibot").StrictObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"USER_NOT_FOUND", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<404, undefined>;
+                }, undefined>, import("valibot").StrictObjectSchema<{
+                    readonly data: import("valibot").StrictObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"USER_MARKED_FOR_DELETION", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<409, undefined>;
+                }, undefined>, import("valibot").StrictObjectSchema<{
+                    readonly data: import("valibot").StrictObjectSchema<{
+                        accessToken: import("valibot").StringSchema<undefined>;
+                        user: import("valibot").ObjectSchema<{
+                            readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
+                            readonly emailVerified: import("valibot").BooleanSchema<undefined>;
+                            readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly profilePictureUrl: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        }, undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<200, undefined>;
+                }, undefined>], undefined>>;
+            };
             refreshAuth: EndpointConfig<"/v1/pb/auth/refresh", import("valibot").ObjectSchema<{
                 readonly refreshToken: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
             }, undefined>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
@@ -139,8 +261,8 @@ export declare const endpoints: {
                 readonly status: import("valibot").LiteralSchema<502, undefined>;
             }, undefined>, import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
-                    readonly accessToken: import("valibot").StringSchema<undefined>;
                     readonly refreshToken: import("valibot").StringSchema<undefined>;
+                    readonly accessToken: import("valibot").StringSchema<undefined>;
                     readonly user: import("valibot").ObjectSchema<{
                         readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
@@ -230,8 +352,8 @@ export declare const endpoints: {
                 readonly status: import("valibot").LiteralSchema<409, undefined>;
             }, undefined>, import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
-                    readonly accessToken: import("valibot").StringSchema<undefined>;
                     readonly refreshToken: import("valibot").StringSchema<undefined>;
+                    readonly accessToken: import("valibot").StringSchema<undefined>;
                     readonly user: import("valibot").ObjectSchema<{
                         readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                         readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;

package/dist/sdk/endpoints/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/endpoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5C,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,qBAAqB,CAAA;AAWtE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGM,CAAA"}
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/endpoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5C,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,qBAAqB,CAAA;AAWtE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGM,CAAA"}

package/dist/sdk/endpoints/public/auth/browser/deleteSession.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+import * as v from 'valibot';
+export declare const deleteSession: import("../../../../..").EndpointConfig<"/v1/pb/auth/browser/session", v.GenericSchema | undefined, v.StrictObjectSchema<{
+    readonly sessionGeneration: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+}, undefined>, v.UnionSchema<[v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+        readonly issues: v.ObjectSchema<{
+            readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+            readonly other: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly status: v.LiteralSchema<204, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=deleteSession.d.ts.map

package/dist/sdk/endpoints/public/auth/browser/deleteSession.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"deleteSession.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/public/auth/browser/deleteSession.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAK5B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;2BAUxB,CAAA"}

package/dist/sdk/endpoints/public/auth/browser/deleteSession.js ADDED Viewed

@@ -0,0 +1,14 @@
+import * as v from 'valibot';
+import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
+import { browserAuthQuerySchema, browserErrorSchemas } from '../../../../../sdk/endpoints/public/auth/browser/schemas';
+export const deleteSession = createEndpoint({
+    method: 'DELETE',
+    path: '/v1/pb/auth/browser/session',
+    query: browserAuthQuerySchema,
+    response: v.union([
+        browserErrorSchemas.validationFailed,
+        v.strictObject({
+            status: v.literal(204),
+        }),
+    ]),
+});

package/dist/sdk/endpoints/public/auth/browser/index.d.ts ADDED Viewed

@@ -0,0 +1,123 @@
+export declare const browser: {
+    deleteSession: import("../../../../..").EndpointConfig<"/v1/pb/auth/browser/session", import("valibot").GenericSchema | undefined, import("valibot").StrictObjectSchema<{
+        readonly sessionGeneration: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
+    }, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly data: import("valibot").StrictObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+            readonly issues: import("valibot").ObjectSchema<{
+                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<400, undefined>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly status: import("valibot").LiteralSchema<204, undefined>;
+    }, undefined>], undefined>>;
+    refreshAuth: import("../../../../..").EndpointConfig<"/v1/pb/auth/browser/refresh", import("valibot").GenericSchema | undefined, import("valibot").StrictObjectSchema<{
+        readonly sessionGeneration: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
+    }, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly data: import("valibot").StrictObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+            readonly issues: import("valibot").ObjectSchema<{
+                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<400, undefined>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly data: import("valibot").StrictObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<401, undefined>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly data: import("valibot").StrictObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<502, undefined>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly data: import("valibot").StrictObjectSchema<{
+            accessToken: import("valibot").StringSchema<undefined>;
+            user: import("valibot").ObjectSchema<{
+                readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
+                readonly emailVerified: import("valibot").BooleanSchema<undefined>;
+                readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly profilePictureUrl: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<200, undefined>;
+    }, undefined>], undefined>>;
+    verifyAuthCode: import("../../../../..").EndpointConfig<"/v1/pb/auth/browser/verify-code", import("valibot").ObjectSchema<{
+        readonly authType: import("valibot").LiteralSchema<"CODE", undefined>;
+        readonly code: import("valibot").StringSchema<undefined>;
+        readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly sessionGeneration: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
+    }, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+        readonly data: import("valibot").StrictObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+            readonly issues: import("valibot").ObjectSchema<{
+                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<400, undefined>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly data: import("valibot").StrictObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<401, undefined>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly data: import("valibot").StrictObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"AUTH_CODE_INVALID", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<401, undefined>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly data: import("valibot").StrictObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<401, undefined>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly data: import("valibot").StrictObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<401, undefined>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly data: import("valibot").StrictObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<502, undefined>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly data: import("valibot").StrictObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"USER_NOT_FOUND", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<404, undefined>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly data: import("valibot").StrictObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"USER_MARKED_FOR_DELETION", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<409, undefined>;
+    }, undefined>, import("valibot").StrictObjectSchema<{
+        readonly data: import("valibot").StrictObjectSchema<{
+            accessToken: import("valibot").StringSchema<undefined>;
+            user: import("valibot").ObjectSchema<{
+                readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
+                readonly emailVerified: import("valibot").BooleanSchema<undefined>;
+                readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly profilePictureUrl: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<200, undefined>;
+    }, undefined>], undefined>>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/sdk/endpoints/public/auth/browser/index.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/public/auth/browser/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAInB,CAAA"}

package/dist/sdk/endpoints/public/auth/browser/index.js ADDED Viewed

@@ -0,0 +1,8 @@
+import { deleteSession } from './deleteSession';
+import { refreshAuth } from './refreshAuth';
+import { verifyAuthCode } from './verifyAuthCode';
+export const browser = {
+    deleteSession,
+    refreshAuth,
+    verifyAuthCode,
+};

package/dist/sdk/endpoints/public/auth/browser/refreshAuth.d.ts ADDED Viewed

@@ -0,0 +1,40 @@
+import * as v from 'valibot';
+export declare const refreshAuth: import("../../../../..").EndpointConfig<"/v1/pb/auth/browser/refresh", v.GenericSchema | undefined, v.StrictObjectSchema<{
+    readonly sessionGeneration: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+}, undefined>, v.UnionSchema<[v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+        readonly issues: v.ObjectSchema<{
+            readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+            readonly other: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<502, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        accessToken: v.StringSchema<undefined>;
+        user: v.ObjectSchema<{
+            readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly email: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>;
+            readonly emailVerified: v.BooleanSchema<undefined>;
+            readonly firstName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly lastName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly profilePictureUrl: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=refreshAuth.d.ts.map

package/dist/sdk/endpoints/public/auth/browser/refreshAuth.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"refreshAuth.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/public/auth/browser/refreshAuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAS5B,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAUtB,CAAA"}

package/dist/sdk/endpoints/public/auth/browser/refreshAuth.js ADDED Viewed

@@ -0,0 +1,14 @@
+import * as v from 'valibot';
+import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
+import { browserAuthQuerySchema, browserAuthSuccessResponseSchema, browserErrorSchemas, } from '../../../../../sdk/endpoints/public/auth/browser/schemas';
+export const refreshAuth = createEndpoint({
+    method: 'POST',
+    path: '/v1/pb/auth/browser/refresh',
+    query: browserAuthQuerySchema,
+    response: v.union([
+        browserErrorSchemas.validationFailed,
+        browserErrorSchemas.authRefreshTokenInvalid,
+        browserErrorSchemas.authServerResponseUnexpected,
+        browserAuthSuccessResponseSchema,
+    ]),
+});

package/dist/sdk/endpoints/public/auth/browser/schemas.d.ts ADDED Viewed

@@ -0,0 +1,82 @@
+import * as v from 'valibot';
+export declare const browserAuthQuerySchema: v.StrictObjectSchema<{
+    readonly sessionGeneration: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+}, undefined>;
+export declare const browserAuthSuccessResponseSchema: v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        accessToken: v.StringSchema<undefined>;
+        user: v.ObjectSchema<{
+            readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly email: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>;
+            readonly emailVerified: v.BooleanSchema<undefined>;
+            readonly firstName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly lastName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly profilePictureUrl: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>;
+export declare const browserErrorSchemas: {
+    readonly authCodeExpired: v.StrictObjectSchema<{
+        readonly data: v.StrictObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<401, undefined>;
+    }, undefined>;
+    readonly authCodeInvalid: v.StrictObjectSchema<{
+        readonly data: v.StrictObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_CODE_INVALID", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<401, undefined>;
+    }, undefined>;
+    readonly authCodePreviouslyUsed: v.StrictObjectSchema<{
+        readonly data: v.StrictObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<401, undefined>;
+    }, undefined>;
+    readonly authRefreshTokenInvalid: v.StrictObjectSchema<{
+        readonly data: v.StrictObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<401, undefined>;
+    }, undefined>;
+    readonly authServerResponseUnexpected: v.StrictObjectSchema<{
+        readonly data: v.StrictObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<502, undefined>;
+    }, undefined>;
+    readonly authTooManyAttempts: v.StrictObjectSchema<{
+        readonly data: v.StrictObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<401, undefined>;
+    }, undefined>;
+    readonly userMarkedForDeletion: v.StrictObjectSchema<{
+        readonly data: v.StrictObjectSchema<{
+            readonly code: v.LiteralSchema<"USER_MARKED_FOR_DELETION", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<409, undefined>;
+    }, undefined>;
+    readonly userNotFound: v.StrictObjectSchema<{
+        readonly data: v.StrictObjectSchema<{
+            readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<404, undefined>;
+    }, undefined>;
+    readonly validationFailed: v.StrictObjectSchema<{
+        readonly data: v.StrictObjectSchema<{
+            readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+            readonly issues: v.ObjectSchema<{
+                readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                readonly other: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+                readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<400, undefined>;
+    }, undefined>;
+};
+//# sourceMappingURL=schemas.d.ts.map

package/dist/sdk/endpoints/public/auth/browser/schemas.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/public/auth/browser/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAkB5B,eAAO,MAAM,sBAAsB;;aAEjC,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;aAG3C,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCtB,CAAA"}

package/dist/sdk/endpoints/public/auth/browser/schemas.js ADDED Viewed

@@ -0,0 +1,25 @@
+import * as v from 'valibot';
+import { authResponseDataEntries } from '../../../../../sdk/endpoints/public/auth/schemas';
+import { errors } from '../../../../../sdk/validation/errors';
+const createBrowserErrorResponseSchema = (data, status) => v.strictObject({
+    data: v.strictObject(data.entries),
+    status,
+});
+export const browserAuthQuerySchema = v.strictObject({
+    sessionGeneration: v.pipe(v.string(), v.uuid()),
+});
+export const browserAuthSuccessResponseSchema = v.strictObject({
+    data: v.strictObject(authResponseDataEntries),
+    status: v.literal(200),
+});
+export const browserErrorSchemas = {
+    authCodeExpired: createBrowserErrorResponseSchema(errors.authCodeExpiredErrorSchema.entries.data, errors.authCodeExpiredErrorSchema.entries.status),
+    authCodeInvalid: createBrowserErrorResponseSchema(errors.authCodeInvalidErrorSchema.entries.data, errors.authCodeInvalidErrorSchema.entries.status),
+    authCodePreviouslyUsed: createBrowserErrorResponseSchema(errors.authCodePreviouslyUsedErrorSchema.entries.data, errors.authCodePreviouslyUsedErrorSchema.entries.status),
+    authRefreshTokenInvalid: createBrowserErrorResponseSchema(errors.authRefreshTokenInvalid.entries.data, errors.authRefreshTokenInvalid.entries.status),
+    authServerResponseUnexpected: createBrowserErrorResponseSchema(errors.authServerResponseUnexpectedErrorSchema.entries.data, errors.authServerResponseUnexpectedErrorSchema.entries.status),
+    authTooManyAttempts: createBrowserErrorResponseSchema(errors.authTooManyAttemptsErrorSchema.entries.data, errors.authTooManyAttemptsErrorSchema.entries.status),
+    userMarkedForDeletion: createBrowserErrorResponseSchema(errors.userMarkedForDeletionErrorSchema.entries.data, errors.userMarkedForDeletionErrorSchema.entries.status),
+    userNotFound: createBrowserErrorResponseSchema(errors.userNotFoundErrorSchema.entries.data, errors.userNotFoundErrorSchema.entries.status),
+    validationFailed: createBrowserErrorResponseSchema(errors.validationFailedErrorSchema.entries.data, errors.validationFailedErrorSchema.entries.status),
+};

package/dist/sdk/endpoints/public/auth/browser/verifyAuthCode.d.ts ADDED Viewed

@@ -0,0 +1,69 @@
+import * as v from 'valibot';
+export declare const verifyAuthCode: import("../../../../..").EndpointConfig<"/v1/pb/auth/browser/verify-code", v.ObjectSchema<{
+    readonly authType: v.LiteralSchema<"CODE", undefined>;
+    readonly code: v.StringSchema<undefined>;
+    readonly email: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly sessionGeneration: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+}, undefined>, v.UnionSchema<[v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+        readonly issues: v.ObjectSchema<{
+            readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+            readonly other: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_CODE_INVALID", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<502, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"USER_MARKED_FOR_DELETION", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<409, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        accessToken: v.StringSchema<undefined>;
+        user: v.ObjectSchema<{
+            readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly email: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>;
+            readonly emailVerified: v.BooleanSchema<undefined>;
+            readonly firstName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly lastName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly profilePictureUrl: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=verifyAuthCode.d.ts.map

package/dist/sdk/endpoints/public/auth/browser/verifyAuthCode.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"verifyAuthCode.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/public/auth/browser/verifyAuthCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAU5B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAgBzB,CAAA"}