@marcoappio/marco-config 7.0.0 → 8.0.0

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

@@ -0,0 +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

@@ -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

@@ -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

@@ -0,0 +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

@@ -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

@@ -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

@@ -0,0 +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"}

package/dist/sdk/endpoints/public/auth/browser/verifyAuthCode.js

@@ -0,0 +1,21 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../../../../../schemas';
+import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
+import { browserAuthQuerySchema, browserAuthSuccessResponseSchema, browserErrorSchemas, } from '../../../../../sdk/endpoints/public/auth/browser/schemas';
+export const verifyAuthCode = createEndpoint({
+    body: marcoSchemas.auth.code,
+    method: 'POST',
+    path: '/v1/pb/auth/browser/verify-code',
+    query: browserAuthQuerySchema,
+    response: v.union([
+        browserErrorSchemas.validationFailed,
+        browserErrorSchemas.authCodeExpired,
+        browserErrorSchemas.authCodeInvalid,
+        browserErrorSchemas.authCodePreviouslyUsed,
+        browserErrorSchemas.authTooManyAttempts,
+        browserErrorSchemas.authServerResponseUnexpected,
+        browserErrorSchemas.userNotFound,
+        browserErrorSchemas.userMarkedForDeletion,
+        browserAuthSuccessResponseSchema,
+    ]),
+});

package/dist/sdk/endpoints/public/auth/index.d.ts

@@ -1,4 +1,126 @@
 export declare const auth: {
+    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>>;
+    };
     refreshAuth: import("../../../..").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>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
@@ -23,8 +145,8 @@ export declare const auth: {
         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>;
@@ -114,8 +236,8 @@ export declare const auth: {
         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/public/auth/index.d.ts.map

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

package/dist/sdk/endpoints/public/auth/index.js

@@ -1,7 +1,9 @@
+import { browser } from './browser';
 import { refreshAuth } from './refreshAuth';
 import { sendAuthCode } from './sendAuthCode';
 import { verifyAuthCode } from './verifyAuthCode';
 export const auth = {
+    browser,
     refreshAuth,
     sendAuthCode,
     verifyAuthCode,

package/dist/sdk/endpoints/public/auth/refreshAuth.d.ts

@@ -23,8 +23,8 @@ export declare const refreshAuth: import("../../../..").EndpointConfig<"/v1/pb/a
     readonly status: v.LiteralSchema<502, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly data: v.ObjectSchema<{
-        readonly accessToken: v.StringSchema<undefined>;
         readonly refreshToken: v.StringSchema<undefined>;
+        readonly accessToken: v.StringSchema<undefined>;
         readonly 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>;

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

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

package/dist/sdk/endpoints/public/auth/refreshAuth.js

@@ -1,6 +1,7 @@
 import * as v from 'valibot';
 import { marcoSchemas } from '../../../../schemas';
 import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
+import { legacyAuthResponseDataSchema } from '../../../../sdk/endpoints/public/auth/schemas';
 import { errors } from '../../../../sdk/validation/errors';
 export const refreshAuth = createEndpoint({
     body: v.object({
@@ -13,20 +14,7 @@ export const refreshAuth = createEndpoint({
         errors.authRefreshTokenInvalid,
         errors.authServerResponseUnexpectedErrorSchema,
         v.object({
-            data: v.object({
-                accessToken: v.string(),
-                refreshToken: v.string(),
-                user: v.object({
-                    createdAt: marcoSchemas.string.required(),
-                    email: marcoSchemas.string.email(),
-                    emailVerified: v.boolean(),
-                    firstName: marcoSchemas.string.nullable(),
-                    id: marcoSchemas.string.required(),
-                    lastName: marcoSchemas.string.nullable(),
-                    profilePictureUrl: marcoSchemas.string.nullable(),
-                    updatedAt: marcoSchemas.string.required(),
-                }),
-            }),
+            data: legacyAuthResponseDataSchema,
             status: v.literal(200),
         }),
     ]),

package/dist/sdk/endpoints/public/auth/schemas.d.ts

@@ -0,0 +1,39 @@
+import * as v from 'valibot';
+export declare const authUserSchema: 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>;
+export declare const authResponseDataEntries: {
+    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>;
+};
+export declare const legacyAuthResponseDataSchema: v.ObjectSchema<{
+    readonly refreshToken: v.StringSchema<undefined>;
+    readonly accessToken: v.StringSchema<undefined>;
+    readonly 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>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/auth/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B,eAAO,MAAM,cAAc;;;;;;;;;aASzB,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;CAGnC,CAAA;AAED,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;aAGvC,CAAA"}

package/dist/sdk/endpoints/public/auth/schemas.js

@@ -0,0 +1,20 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../../../../schemas';
+export const authUserSchema = v.object({
+    createdAt: marcoSchemas.string.required(),
+    email: marcoSchemas.string.email(),
+    emailVerified: v.boolean(),
+    firstName: marcoSchemas.string.nullable(),
+    id: marcoSchemas.string.required(),
+    lastName: marcoSchemas.string.nullable(),
+    profilePictureUrl: marcoSchemas.string.nullable(),
+    updatedAt: marcoSchemas.string.required(),
+});
+export const authResponseDataEntries = {
+    accessToken: v.string(),
+    user: authUserSchema,
+};
+export const legacyAuthResponseDataSchema = v.object({
+    ...authResponseDataEntries,
+    refreshToken: v.string(),
+});

package/dist/sdk/endpoints/public/auth/verifyAuthCode.d.ts

@@ -50,8 +50,8 @@ export declare const verifyAuthCode: import("../../../..").EndpointConfig<"/v1/p
     readonly status: v.LiteralSchema<409, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly data: v.ObjectSchema<{
-        readonly accessToken: v.StringSchema<undefined>;
         readonly refreshToken: v.StringSchema<undefined>;
+        readonly accessToken: v.StringSchema<undefined>;
         readonly 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>;

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

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

package/dist/sdk/endpoints/public/auth/verifyAuthCode.js

@@ -1,6 +1,7 @@
 import * as v from 'valibot';
 import { marcoSchemas } from '../../../../schemas';
 import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
+import { legacyAuthResponseDataSchema } from '../../../../sdk/endpoints/public/auth/schemas';
 import { errors } from '../../../../sdk/validation/errors';
 export const verifyAuthCode = createEndpoint({
     body: marcoSchemas.auth.code,
@@ -16,20 +17,7 @@ export const verifyAuthCode = createEndpoint({
         errors.userNotFoundErrorSchema,
         errors.userMarkedForDeletionErrorSchema,
         v.object({
-            data: v.object({
-                accessToken: v.string(),
-                refreshToken: v.string(),
-                user: v.object({
-                    createdAt: marcoSchemas.string.required(),
-                    email: marcoSchemas.string.email(),
-                    emailVerified: v.boolean(),
-                    firstName: marcoSchemas.string.nullable(),
-                    id: marcoSchemas.string.required(),
-                    lastName: marcoSchemas.string.nullable(),
-                    profilePictureUrl: marcoSchemas.string.nullable(),
-                    updatedAt: marcoSchemas.string.required(),
-                }),
-            }),
+            data: legacyAuthResponseDataSchema,
             status: v.literal(200),
         }),
     ]),