@marcoappio/marco-config 2.0.598 → 3.0.0

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

@@ -1,133 +0,0 @@
-export declare const auth: {
-    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<{
-        readonly data: import("valibot").ObjectSchema<{
-            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").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<401, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
-        }, undefined>;
-        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 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>>;
-    sendAuthCode: import("../../../..").EndpointConfig<"/v1/pb/auth/send-code", import("valibot").ObjectSchema<{
-        readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
-    }, undefined>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            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").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<502, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"INVITE_NOT_FOUND", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<404, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly status: import("valibot").LiteralSchema<200, undefined>;
-    }, undefined>], undefined>>;
-    verifyAuthCode: import("../../../..").EndpointConfig<"/v1/pb/auth/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").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            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").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<401, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_CODE_INVALID", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<401, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<401, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<401, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<502, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"USER_NOT_FOUND", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<404, undefined>;
-    }, undefined>, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"USER_MARKED_FOR_DELETION", undefined>;
-        }, undefined>;
-        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 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/index.d.ts.map

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

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

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

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

@@ -1,41 +0,0 @@
-import * as v from 'valibot';
-export declare const refreshAuth: import("../../../..").EndpointConfig<"/v1/pb/auth/refresh", v.ObjectSchema<{
-    readonly refreshToken: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-}, undefined>, v.GenericSchema | undefined, v.UnionSchema<[v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        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.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<401, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<502, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly accessToken: v.StringSchema<undefined>;
-        readonly refreshToken: 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>;
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=refreshAuth.d.ts.map

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

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

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

@@ -1,33 +0,0 @@
-import * as v from 'valibot';
-import { marcoSchemas } from '../../../../schemas';
-import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { errors } from '../../../../sdk/validation/errors';
-export const refreshAuth = createEndpoint({
-    body: v.object({
-        refreshToken: marcoSchemas.string.required(),
-    }),
-    method: 'POST',
-    path: '/v1/pb/auth/refresh',
-    response: v.union([
-        errors.validationFailedErrorSchema,
-        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(),
-                }),
-            }),
-            status: v.literal(200),
-        }),
-    ]),
-});

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

@@ -1,27 +0,0 @@
-import * as v from 'valibot';
-export declare const sendAuthCode: import("../../../..").EndpointConfig<"/v1/pb/auth/send-code", v.ObjectSchema<{
-    readonly email: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>;
-}, undefined>, v.GenericSchema | undefined, v.UnionSchema<[v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        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.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<502, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"INVITE_NOT_FOUND", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<404, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=sendAuthCode.d.ts.map

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

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

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

@@ -1,19 +0,0 @@
-import * as v from 'valibot';
-import { marcoSchemas } from '../../../../schemas';
-import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { errors } from '../../../../sdk/validation/errors';
-export const sendAuthCode = createEndpoint({
-    body: v.object({
-        email: marcoSchemas.string.email(),
-    }),
-    method: 'POST',
-    path: '/v1/pb/auth/send-code',
-    response: v.union([
-        errors.validationFailedErrorSchema,
-        errors.authServerResponseUnexpectedErrorSchema,
-        errors.inviteNotFoundErrorSchema,
-        v.object({
-            status: v.literal(200),
-        }),
-    ]),
-});

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

@@ -1,68 +0,0 @@
-import * as v from 'valibot';
-export declare const verifyAuthCode: import("../../../..").EndpointConfig<"/v1/pb/auth/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.GenericSchema | undefined, v.UnionSchema<[v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        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.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<401, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTH_CODE_INVALID", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<401, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<401, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<401, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<502, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<404, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"USER_MARKED_FOR_DELETION", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<409, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly accessToken: v.StringSchema<undefined>;
-        readonly refreshToken: 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>;
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=verifyAuthCode.d.ts.map

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

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

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

@@ -1,36 +0,0 @@
-import * as v from 'valibot';
-import { marcoSchemas } from '../../../../schemas';
-import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { errors } from '../../../../sdk/validation/errors';
-export const verifyAuthCode = createEndpoint({
-    body: marcoSchemas.auth.code,
-    method: 'POST',
-    path: '/v1/pb/auth/verify-code',
-    response: v.union([
-        errors.validationFailedErrorSchema,
-        errors.authCodeExpiredErrorSchema,
-        errors.authCodeInvalidErrorSchema,
-        errors.authCodePreviouslyUsedErrorSchema,
-        errors.authTooManyAttemptsErrorSchema,
-        errors.authServerResponseUnexpectedErrorSchema,
-        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(),
-                }),
-            }),
-            status: v.literal(200),
-        }),
-    ]),
-});

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

@@ -1,10 +0,0 @@
-import * as v from 'valibot';
-export declare const config: import("../../../..").EndpointConfig<"/v1/pb/config", v.GenericSchema | undefined, v.GenericSchema | undefined, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly app: v.ObjectSchema<{
-            readonly minimumVersion: 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>>;
-//# sourceMappingURL=index.d.ts.map

package/dist/sdk/endpoints/public/config/index.d.ts.map

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

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

@@ -1,15 +0,0 @@
-import * as v from 'valibot';
-import { marcoSchemas } from '../../../../schemas';
-import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-export const config = createEndpoint({
-    method: 'GET',
-    path: '/v1/pb/config',
-    response: v.object({
-        data: v.object({
-            app: v.object({
-                minimumVersion: marcoSchemas.string.required(),
-            }),
-        }),
-        status: v.literal(200),
-    }),
-});

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

@@ -1,8 +0,0 @@
-import * as v from 'valibot';
-export declare const healthcheck: import("../../../..").EndpointConfig<"/v1/pb/healthcheck", v.GenericSchema | undefined, v.GenericSchema | undefined, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly status: v.LiteralSchema<"ok", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>>;
-//# sourceMappingURL=index.d.ts.map

package/dist/sdk/endpoints/public/healthcheck/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/public/healthcheck/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B,eAAO,MAAM,WAAW;;;;;cAOtB,CAAA"}

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

@@ -1,10 +0,0 @@
-import * as v from 'valibot';
-import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-export const healthcheck = createEndpoint({
-    method: 'GET',
-    path: '/v1/pb/healthcheck',
-    response: v.object({
-        data: v.object({ status: v.literal('ok') }),
-        status: v.literal(200),
-    }),
-});

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

@@ -1,149 +0,0 @@
-export declare const publicGroup: {
-    auth: {
-        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<{
-            readonly data: import("valibot").ObjectSchema<{
-                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").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<401, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
-            }, undefined>;
-            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 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>>;
-        sendAuthCode: import("../../..").EndpointConfig<"/v1/pb/auth/send-code", import("valibot").ObjectSchema<{
-            readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
-        }, undefined>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                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").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<502, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"INVITE_NOT_FOUND", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<404, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly status: import("valibot").LiteralSchema<200, undefined>;
-        }, undefined>], undefined>>;
-        verifyAuthCode: import("../../..").EndpointConfig<"/v1/pb/auth/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").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                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").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<401, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"AUTH_CODE_INVALID", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<401, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<401, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<401, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<502, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"USER_NOT_FOUND", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<404, undefined>;
-        }, undefined>, import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"USER_MARKED_FOR_DELETION", undefined>;
-            }, undefined>;
-            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 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>>;
-    };
-    config: import("../../..").EndpointConfig<"/v1/pb/config", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly app: import("valibot").ObjectSchema<{
-                readonly minimumVersion: 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>>;
-    healthcheck: import("../../..").EndpointConfig<"/v1/pb/healthcheck", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").ObjectSchema<{
-        readonly data: import("valibot").ObjectSchema<{
-            readonly status: import("valibot").LiteralSchema<"ok", undefined>;
-        }, undefined>;
-        readonly status: import("valibot").LiteralSchema<200, undefined>;
-    }, undefined>>;
-};
-//# sourceMappingURL=index.d.ts.map