@marcoappio/marco-config 2.0.599 → 3.0.1

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

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

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

@@ -1,8 +0,0 @@
-import { auth } from './auth';
-import { config } from './config';
-import { healthcheck } from './healthcheck';
-export const publicGroup = {
-    auth,
-    config,
-    healthcheck,
-};

package/dist/sdk/index.d.ts

@@ -1,485 +0,0 @@
-export declare const marcoSDK: {
-    endpoints: {
-        private: {
-            draftAttachment: {
-                upload: import("..").EndpointConfig<"/v1/pv/drafts/:attachmentId/upload", import("valibot").BlobSchema<undefined>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<401, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"ATTACHMENT_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<"ATTACHMENT_STATE_INVALID", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<409, undefined>;
-                }, undefined>, 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 status: import("valibot").LiteralSchema<200, undefined>;
-                }, undefined>], undefined>>;
-            };
-            emailMessage: {
-                getAttachment: import("..").EndpointConfig<"/v1/pv/attachment/:attachmentId", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<401, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"ATTACHMENT_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<"ATTACHMENT_STATE_INVALID", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<409, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly file: import("valibot").NonOptionalSchema<import("valibot").FileSchema<undefined>, undefined>;
-                    readonly status: import("valibot").LiteralSchema<200, undefined>;
-                }, undefined>], undefined>>;
-            };
-            models: {
-                account: typeof import("./endpoints/private/models/account");
-                contact: typeof import("./endpoints/private/models/contact");
-                draft: typeof import("./endpoints/private/models/draft");
-                thread: typeof import("./endpoints/private/models/thread");
-                user: typeof import("./endpoints/private/models/user");
-            };
-            mutations: {
-                account: typeof import("./endpoints/private/mutations/account");
-                draft: typeof import("./endpoints/private/mutations/draft");
-                thread: typeof import("./endpoints/private/mutations/thread");
-                user: typeof import("./endpoints/private/mutations/user");
-            };
-            user: {
-                createBillingPortalSession: import("..").EndpointConfig<"/v1/pv/user/create-billing-portal-session", import("valibot").ObjectSchema<{
-                    readonly returnUrl: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
-                }, undefined>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<401, undefined>;
-                }, undefined>, 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<"SUBSCRIPTION_NOT_FOUND", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<404, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly url: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<200, undefined>;
-                }, undefined>], undefined>>;
-                createCheckoutSession: import("..").EndpointConfig<"/v1/pv/user/create-checkout-session", import("valibot").ObjectSchema<{
-                    readonly cancelUrl: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
-                    readonly priceId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
-                    readonly successUrl: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
-                }, undefined>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<401, undefined>;
-                }, undefined>, 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 url: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<200, undefined>;
-                }, undefined>], undefined>>;
-                deleteUser: import("..").EndpointConfig<"/v1/pv/user", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<401, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly status: import("valibot").LiteralSchema<204, undefined>;
-                }, undefined>], undefined>>;
-                uploadProfilePicture: import("..").EndpointConfig<"/v1/pv/user/profile-picture", import("valibot").BlobSchema<undefined>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<401, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"FILE_TOO_LARGE", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<413, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"INVALID_FILE_TYPE", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<415, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"INVALID_IMAGE_DIMENSIONS", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<415, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly profilePicture: import("valibot").StringSchema<undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<200, undefined>;
-                }, undefined>], undefined>>;
-            };
-        };
-        public: {
-            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>>;
-        };
-    };
-    validation: {
-        errors: {
-            readonly accountNotFoundErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"ACCOUNT_NOT_FOUND", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<404, undefined>;
-            }, undefined>;
-            readonly aliasNotFoundErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"ALIAS_NOT_FOUND", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<404, undefined>;
-            }, undefined>;
-            readonly attachmentNotFoundErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"ATTACHMENT_NOT_FOUND", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<404, undefined>;
-            }, undefined>;
-            readonly attachmentStateInvalidErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"ATTACHMENT_STATE_INVALID", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<409, undefined>;
-            }, undefined>;
-            readonly authCodeExpiredErrorSchema: 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>;
-            readonly authCodeInvalidErrorSchema: 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>;
-            readonly authCodePreviouslyUsedErrorSchema: 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>;
-            readonly authFailedErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<401, undefined>;
-            }, undefined>;
-            readonly authRefreshTokenInvalid: 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>;
-            readonly authServerResponseUnexpectedErrorSchema: 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>;
-            readonly authTooManyAttemptsErrorSchema: 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>;
-            readonly contactNotFoundErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"CONTACT_NOT_FOUND", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<404, undefined>;
-            }, undefined>;
-            readonly draftNotFoundErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"DRAFT_NOT_FOUND", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<404, undefined>;
-            }, undefined>;
-            readonly fileTooLargeErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"FILE_TOO_LARGE", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<413, undefined>;
-            }, undefined>;
-            readonly invalidFileTypeErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"INVALID_FILE_TYPE", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<415, undefined>;
-            }, undefined>;
-            readonly invalidImageDimensionsErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"INVALID_IMAGE_DIMENSIONS", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<415, undefined>;
-            }, undefined>;
-            readonly inviteNotFoundErrorSchema: 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>;
-            readonly labelAlreadyExistsErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"LABEL_ALREADY_EXISTS", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<409, undefined>;
-            }, undefined>;
-            readonly labelNotFoundErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"LABEL_NOT_FOUND", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<404, undefined>;
-            }, undefined>;
-            readonly messageNotFoundErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<404, undefined>;
-            }, undefined>;
-            readonly mutationRejectedErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"MUTATION_REJECTED", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<409, undefined>;
-            }, undefined>;
-            readonly subscriptionNotFoundErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"SUBSCRIPTION_NOT_FOUND", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<404, undefined>;
-            }, undefined>;
-            readonly threadNotFoundErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"THREAD_NOT_FOUND", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<404, undefined>;
-            }, undefined>;
-            readonly userMarkedForDeletionErrorSchema: 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>;
-            readonly userNotFoundErrorSchema: 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>;
-            readonly validationFailedErrorSchema: 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>;
-            readonly viewNotFoundErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"VIEW_NOT_FOUND", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<404, undefined>;
-            }, undefined>;
-        };
-        utils: {
-            flattenRequirements: <T extends Record<string, any>>(schema: import("valibot").ObjectSchema<T, any>) => { [K in keyof T]: {
-                maxLength?: number;
-                minLength?: number;
-            }; };
-        };
-    };
-};
-//# sourceMappingURL=index.d.ts.map

package/dist/sdk/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sdk/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGpB,CAAA"}

package/dist/sdk/index.js

@@ -1,6 +0,0 @@
-import { endpoints } from './endpoints';
-import { validation } from './validation';
-export const marcoSDK = {
-    endpoints,
-    validation,
-};