@marcoappio/marco-config 4.0.26 → 6.0.0

package/dist/sdk/validation/errors.d.ts

@@ -0,0 +1,326 @@
+import * as v from 'valibot';
+export declare const inviteNotFoundErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"INVITE_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>;
+export declare const authCodeExpiredErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>;
+export declare const authCodeInvalidErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_CODE_INVALID", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>;
+export declare const authTooManyAttemptsErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>;
+export declare const authCodePreviouslyUsedErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>;
+export declare const authServerResponseUnexpectedErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<502, undefined>;
+}, undefined>;
+export declare const authFailedErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>;
+export declare const authRefreshTokenInvalid: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>;
+export declare const userNotFoundErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>;
+export declare const userMarkedForDeletionErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"USER_MARKED_FOR_DELETION", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<409, undefined>;
+}, undefined>;
+export declare const messageNotFoundErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>;
+export declare const attachmentNotFoundErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"ATTACHMENT_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>;
+export declare const attachmentStateInvalidErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"ATTACHMENT_STATE_INVALID", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<409, undefined>;
+}, undefined>;
+export declare const accountNotFoundErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"ACCOUNT_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>;
+export declare const mutationRejectedErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"MUTATION_REJECTED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<409, undefined>;
+}, undefined>;
+export declare const threadNotFoundErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"THREAD_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>;
+export declare const draftNotFoundErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"DRAFT_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>;
+export declare const contactNotFoundErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"CONTACT_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>;
+export declare const labelAlreadyExistsErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"LABEL_ALREADY_EXISTS", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<409, undefined>;
+}, undefined>;
+export declare const labelNotFoundErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"LABEL_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>;
+export declare const aliasNotFoundErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"ALIAS_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>;
+export declare const viewNotFoundErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"VIEW_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>;
+export declare const validationFailedErrorSchema: 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>;
+export declare const fileTooLargeErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"FILE_TOO_LARGE", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<413, undefined>;
+}, undefined>;
+export declare const invalidFileTypeErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"INVALID_FILE_TYPE", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<415, undefined>;
+}, undefined>;
+export declare const invalidImageDimensionsErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"INVALID_IMAGE_DIMENSIONS", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<415, undefined>;
+}, undefined>;
+export declare const errors: {
+    readonly accountNotFoundErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"ACCOUNT_NOT_FOUND", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<404, undefined>;
+    }, undefined>;
+    readonly aliasNotFoundErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"ALIAS_NOT_FOUND", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<404, undefined>;
+    }, undefined>;
+    readonly attachmentNotFoundErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"ATTACHMENT_NOT_FOUND", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<404, undefined>;
+    }, undefined>;
+    readonly attachmentStateInvalidErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"ATTACHMENT_STATE_INVALID", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<409, undefined>;
+    }, undefined>;
+    readonly authCodeExpiredErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<401, undefined>;
+    }, undefined>;
+    readonly authCodeInvalidErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_CODE_INVALID", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<401, undefined>;
+    }, undefined>;
+    readonly authCodePreviouslyUsedErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<401, undefined>;
+    }, undefined>;
+    readonly authFailedErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<401, undefined>;
+    }, undefined>;
+    readonly authRefreshTokenInvalid: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<401, undefined>;
+    }, undefined>;
+    readonly authServerResponseUnexpectedErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<502, undefined>;
+    }, undefined>;
+    readonly authTooManyAttemptsErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<401, undefined>;
+    }, undefined>;
+    readonly contactNotFoundErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"CONTACT_NOT_FOUND", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<404, undefined>;
+    }, undefined>;
+    readonly draftNotFoundErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"DRAFT_NOT_FOUND", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<404, undefined>;
+    }, undefined>;
+    readonly fileTooLargeErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"FILE_TOO_LARGE", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<413, undefined>;
+    }, undefined>;
+    readonly invalidFileTypeErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"INVALID_FILE_TYPE", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<415, undefined>;
+    }, undefined>;
+    readonly invalidImageDimensionsErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"INVALID_IMAGE_DIMENSIONS", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<415, undefined>;
+    }, undefined>;
+    readonly inviteNotFoundErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"INVITE_NOT_FOUND", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<404, undefined>;
+    }, undefined>;
+    readonly labelAlreadyExistsErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"LABEL_ALREADY_EXISTS", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<409, undefined>;
+    }, undefined>;
+    readonly labelNotFoundErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"LABEL_NOT_FOUND", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<404, undefined>;
+    }, undefined>;
+    readonly messageNotFoundErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<404, undefined>;
+    }, undefined>;
+    readonly mutationRejectedErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"MUTATION_REJECTED", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<409, undefined>;
+    }, undefined>;
+    readonly threadNotFoundErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"THREAD_NOT_FOUND", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<404, undefined>;
+    }, undefined>;
+    readonly userMarkedForDeletionErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"USER_MARKED_FOR_DELETION", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<409, undefined>;
+    }, undefined>;
+    readonly userNotFoundErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<404, undefined>;
+    }, undefined>;
+    readonly validationFailedErrorSchema: 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>;
+    readonly viewNotFoundErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"VIEW_NOT_FOUND", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<404, undefined>;
+    }, undefined>;
+};
+//# sourceMappingURL=errors.d.ts.map

package/dist/sdk/validation/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/sdk/validation/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,yBAAyB;;;;;aAGpC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;aAGzC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,uCAAuC;;;;;aAGlD,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;aAGhC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;aAG3C,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;aAGxC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;aAGtC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;aAGpC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;aAGxC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;aAUtC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BT,CAAA"}

package/dist/sdk/validation/errors.js

@@ -0,0 +1,140 @@
+import * as v from 'valibot';
+export const inviteNotFoundErrorSchema = v.object({
+    data: v.object({ code: v.literal('INVITE_NOT_FOUND') }),
+    status: v.literal(404),
+});
+export const authCodeExpiredErrorSchema = v.object({
+    data: v.object({ code: v.literal('AUTH_CODE_EXPIRED') }),
+    status: v.literal(401),
+});
+export const authCodeInvalidErrorSchema = v.object({
+    data: v.object({ code: v.literal('AUTH_CODE_INVALID') }),
+    status: v.literal(401),
+});
+export const authTooManyAttemptsErrorSchema = v.object({
+    data: v.object({ code: v.literal('AUTH_TOO_MANY_ATTEMPTS') }),
+    status: v.literal(401),
+});
+export const authCodePreviouslyUsedErrorSchema = v.object({
+    data: v.object({ code: v.literal('AUTH_CODE_PREVIOUSLY_USED') }),
+    status: v.literal(401),
+});
+export const authServerResponseUnexpectedErrorSchema = v.object({
+    data: v.object({ code: v.literal('AUTH_SERVER_RESPONSE_UNEXPECTED') }),
+    status: v.literal(502),
+});
+export const authFailedErrorSchema = v.object({
+    data: v.object({ code: v.literal('AUTHENTICATION_FAILED') }),
+    status: v.literal(401),
+});
+export const authRefreshTokenInvalid = v.object({
+    data: v.object({ code: v.literal('AUTH_REFRESH_TOKEN_INVALID') }),
+    status: v.literal(401),
+});
+export const userNotFoundErrorSchema = v.object({
+    data: v.object({ code: v.literal('USER_NOT_FOUND') }),
+    status: v.literal(404),
+});
+export const userMarkedForDeletionErrorSchema = v.object({
+    data: v.object({ code: v.literal('USER_MARKED_FOR_DELETION') }),
+    status: v.literal(409),
+});
+export const messageNotFoundErrorSchema = v.object({
+    data: v.object({ code: v.literal('MESSAGE_NOT_FOUND') }),
+    status: v.literal(404),
+});
+export const attachmentNotFoundErrorSchema = v.object({
+    data: v.object({ code: v.literal('ATTACHMENT_NOT_FOUND') }),
+    status: v.literal(404),
+});
+export const attachmentStateInvalidErrorSchema = v.object({
+    data: v.object({ code: v.literal('ATTACHMENT_STATE_INVALID') }),
+    status: v.literal(409),
+});
+export const accountNotFoundErrorSchema = v.object({
+    data: v.object({ code: v.literal('ACCOUNT_NOT_FOUND') }),
+    status: v.literal(404),
+});
+export const mutationRejectedErrorSchema = v.object({
+    data: v.object({ code: v.literal('MUTATION_REJECTED') }),
+    status: v.literal(409),
+});
+export const threadNotFoundErrorSchema = v.object({
+    data: v.object({ code: v.literal('THREAD_NOT_FOUND') }),
+    status: v.literal(404),
+});
+export const draftNotFoundErrorSchema = v.object({
+    data: v.object({ code: v.literal('DRAFT_NOT_FOUND') }),
+    status: v.literal(404),
+});
+export const contactNotFoundErrorSchema = v.object({
+    data: v.object({ code: v.literal('CONTACT_NOT_FOUND') }),
+    status: v.literal(404),
+});
+export const labelAlreadyExistsErrorSchema = v.object({
+    data: v.object({ code: v.literal('LABEL_ALREADY_EXISTS') }),
+    status: v.literal(409),
+});
+export const labelNotFoundErrorSchema = v.object({
+    data: v.object({ code: v.literal('LABEL_NOT_FOUND') }),
+    status: v.literal(404),
+});
+export const aliasNotFoundErrorSchema = v.object({
+    data: v.object({ code: v.literal('ALIAS_NOT_FOUND') }),
+    status: v.literal(404),
+});
+export const viewNotFoundErrorSchema = v.object({
+    data: v.object({ code: v.literal('VIEW_NOT_FOUND') }),
+    status: v.literal(404),
+});
+export const validationFailedErrorSchema = v.object({
+    data: v.object({
+        code: v.literal('VALIDATION_FAILED'),
+        issues: v.object({
+            nested: v.optional(v.record(v.string(), v.optional(v.array(v.string())))),
+            other: v.optional(v.array(v.string())),
+            root: v.optional(v.array(v.string())),
+        }),
+    }),
+    status: v.literal(400),
+});
+export const fileTooLargeErrorSchema = v.object({
+    data: v.object({ code: v.literal('FILE_TOO_LARGE') }),
+    status: v.literal(413),
+});
+export const invalidFileTypeErrorSchema = v.object({
+    data: v.object({ code: v.literal('INVALID_FILE_TYPE') }),
+    status: v.literal(415),
+});
+export const invalidImageDimensionsErrorSchema = v.object({
+    data: v.object({ code: v.literal('INVALID_IMAGE_DIMENSIONS') }),
+    status: v.literal(415),
+});
+export const errors = {
+    accountNotFoundErrorSchema,
+    aliasNotFoundErrorSchema,
+    attachmentNotFoundErrorSchema,
+    attachmentStateInvalidErrorSchema,
+    authCodeExpiredErrorSchema,
+    authCodeInvalidErrorSchema,
+    authCodePreviouslyUsedErrorSchema,
+    authFailedErrorSchema,
+    authRefreshTokenInvalid,
+    authServerResponseUnexpectedErrorSchema,
+    authTooManyAttemptsErrorSchema,
+    contactNotFoundErrorSchema,
+    draftNotFoundErrorSchema,
+    fileTooLargeErrorSchema,
+    invalidFileTypeErrorSchema,
+    invalidImageDimensionsErrorSchema,
+    inviteNotFoundErrorSchema,
+    labelAlreadyExistsErrorSchema,
+    labelNotFoundErrorSchema,
+    messageNotFoundErrorSchema,
+    mutationRejectedErrorSchema,
+    threadNotFoundErrorSchema,
+    userMarkedForDeletionErrorSchema,
+    userNotFoundErrorSchema,
+    validationFailedErrorSchema,
+    viewNotFoundErrorSchema,
+};

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

@@ -0,0 +1,172 @@
+export declare const 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 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/validation/index.d.ts.map

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

package/dist/sdk/validation/index.js

@@ -0,0 +1,3 @@
+import { errors } from './errors';
+import { utils } from './utils';
+export const validation = { errors, utils };

package/dist/sdk/validation/utils/flattenRequirements/flattenRequirements.d.ts

@@ -0,0 +1,11 @@
+import type * as v from 'valibot';
+type SchemaRequirements = {
+    maxLength?: number;
+    minLength?: number;
+};
+type FlattenedRequirements<T> = {
+    [K in keyof T]: SchemaRequirements;
+};
+export declare const flattenRequirements: <T extends Record<string, any>>(schema: v.ObjectSchema<T, any>) => FlattenedRequirements<T>;
+export {};
+//# sourceMappingURL=flattenRequirements.d.ts.map

package/dist/sdk/validation/utils/flattenRequirements/flattenRequirements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flattenRequirements.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/validation/utils/flattenRequirements/flattenRequirements.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,KAAK,kBAAkB,GAAG;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,KAAK,qBAAqB,CAAC,CAAC,IAAI;KAC7B,CAAC,IAAI,MAAM,CAAC,GAAG,kBAAkB;CACnC,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,UACvD,CAAC,CAAC,YAAY,CAAC,CAAC,EAAE,GAAG,CAAC,KAC7B,qBAAqB,CAAC,CAAC,CA0BzB,CAAA"}