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

@marcoappio/marco-config 6.0.4 → 7.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (57) hide show

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

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

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

@@ -0,0 +1,39 @@
+import * as v from 'valibot';
+export declare const authUserSchema: v.ObjectSchema<{
+    readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    readonly email: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>;
+    readonly emailVerified: v.BooleanSchema<undefined>;
+    readonly firstName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    readonly lastName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    readonly profilePictureUrl: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+}, undefined>;
+export declare const authResponseDataEntries: {
+    accessToken: v.StringSchema<undefined>;
+    user: v.ObjectSchema<{
+        readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly email: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>;
+        readonly emailVerified: v.BooleanSchema<undefined>;
+        readonly firstName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly lastName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly profilePictureUrl: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    }, undefined>;
+};
+export declare const legacyAuthResponseDataSchema: v.ObjectSchema<{
+    readonly refreshToken: v.StringSchema<undefined>;
+    readonly accessToken: v.StringSchema<undefined>;
+    readonly user: v.ObjectSchema<{
+        readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly email: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>;
+        readonly emailVerified: v.BooleanSchema<undefined>;
+        readonly firstName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly lastName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly profilePictureUrl: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    }, undefined>;
+}, undefined>;
+//# sourceMappingURL=schemas.d.ts.map

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

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

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

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

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

@@ -50,8 +50,8 @@ export declare const verifyAuthCode: import("../../../..").EndpointConfig<"/v1/p
     readonly status: v.LiteralSchema<409, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly data: v.ObjectSchema<{
-        readonly accessToken: v.StringSchema<undefined>;
         readonly refreshToken: v.StringSchema<undefined>;
+        readonly accessToken: v.StringSchema<undefined>;
         readonly user: v.ObjectSchema<{
             readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly email: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>;

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

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

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

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

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

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

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

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/sdk/endpoints/public/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~CAIvB,CAAA"}
1	+ {"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/index.d.ts CHANGED Viewed

@@ -12,11 +12,21 @@ export declare const marcoSDK: {
                         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_SIZE_MISMATCH", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<400, 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<"ATTACHMENT_UPLOAD_FAILED", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<500, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly data: import("valibot").ObjectSchema<{
                         readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
@@ -104,6 +114,128 @@ export declare const marcoSDK: {
         };
         public: {
             auth: {
+                browser: {
+                    deleteSession: import("..").EndpointConfig<"/v1/pb/auth/browser/session", import("valibot").GenericSchema | undefined, import("valibot").StrictObjectSchema<{
+                        readonly sessionGeneration: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
+                    }, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+                        readonly data: import("valibot").StrictObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                            readonly issues: import("valibot").ObjectSchema<{
+                                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                                readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<400, undefined>;
+                    }, undefined>, import("valibot").StrictObjectSchema<{
+                        readonly status: import("valibot").LiteralSchema<204, undefined>;
+                    }, undefined>], undefined>>;
+                    refreshAuth: import("..").EndpointConfig<"/v1/pb/auth/browser/refresh", import("valibot").GenericSchema | undefined, import("valibot").StrictObjectSchema<{
+                        readonly sessionGeneration: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
+                    }, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+                        readonly data: import("valibot").StrictObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                            readonly issues: import("valibot").ObjectSchema<{
+                                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                                readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<400, undefined>;
+                    }, undefined>, import("valibot").StrictObjectSchema<{
+                        readonly data: import("valibot").StrictObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<401, undefined>;
+                    }, undefined>, import("valibot").StrictObjectSchema<{
+                        readonly data: import("valibot").StrictObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<502, undefined>;
+                    }, undefined>, import("valibot").StrictObjectSchema<{
+                        readonly data: import("valibot").StrictObjectSchema<{
+                            accessToken: import("valibot").StringSchema<undefined>;
+                            user: import("valibot").ObjectSchema<{
+                                readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
+                                readonly emailVerified: import("valibot").BooleanSchema<undefined>;
+                                readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly profilePictureUrl: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<200, undefined>;
+                    }, undefined>], undefined>>;
+                    verifyAuthCode: import("..").EndpointConfig<"/v1/pb/auth/browser/verify-code", import("valibot").ObjectSchema<{
+                        readonly authType: import("valibot").LiteralSchema<"CODE", undefined>;
+                        readonly code: import("valibot").StringSchema<undefined>;
+                        readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
+                    }, undefined>, import("valibot").StrictObjectSchema<{
+                        readonly sessionGeneration: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UuidAction<string, undefined>]>;
+                    }, undefined>, import("valibot").UnionSchema<[import("valibot").StrictObjectSchema<{
+                        readonly data: import("valibot").StrictObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                            readonly issues: import("valibot").ObjectSchema<{
+                                readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                                readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                                readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<400, undefined>;
+                    }, undefined>, import("valibot").StrictObjectSchema<{
+                        readonly data: import("valibot").StrictObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<401, undefined>;
+                    }, undefined>, import("valibot").StrictObjectSchema<{
+                        readonly data: import("valibot").StrictObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTH_CODE_INVALID", undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<401, undefined>;
+                    }, undefined>, import("valibot").StrictObjectSchema<{
+                        readonly data: import("valibot").StrictObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<401, undefined>;
+                    }, undefined>, import("valibot").StrictObjectSchema<{
+                        readonly data: import("valibot").StrictObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<401, undefined>;
+                    }, undefined>, import("valibot").StrictObjectSchema<{
+                        readonly data: import("valibot").StrictObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<502, undefined>;
+                    }, undefined>, import("valibot").StrictObjectSchema<{
+                        readonly data: import("valibot").StrictObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"USER_NOT_FOUND", undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<404, undefined>;
+                    }, undefined>, import("valibot").StrictObjectSchema<{
+                        readonly data: import("valibot").StrictObjectSchema<{
+                            readonly code: import("valibot").LiteralSchema<"USER_MARKED_FOR_DELETION", undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<409, undefined>;
+                    }, undefined>, import("valibot").StrictObjectSchema<{
+                        readonly data: import("valibot").StrictObjectSchema<{
+                            accessToken: import("valibot").StringSchema<undefined>;
+                            user: import("valibot").ObjectSchema<{
+                                readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
+                                readonly emailVerified: import("valibot").BooleanSchema<undefined>;
+                                readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly profilePictureUrl: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                                readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                            }, undefined>;
+                        }, undefined>;
+                        readonly status: import("valibot").LiteralSchema<200, undefined>;
+                    }, undefined>], undefined>>;
+                };
                 refreshAuth: import("..").EndpointConfig<"/v1/pb/auth/refresh", import("valibot").ObjectSchema<{
                     readonly refreshToken: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                 }, undefined>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
@@ -128,8 +260,8 @@ export declare const marcoSDK: {
                     readonly status: import("valibot").LiteralSchema<502, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly data: import("valibot").ObjectSchema<{
-                        readonly accessToken: import("valibot").StringSchema<undefined>;
                         readonly refreshToken: import("valibot").StringSchema<undefined>;
+                        readonly accessToken: import("valibot").StringSchema<undefined>;
                         readonly user: import("valibot").ObjectSchema<{
                             readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                             readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
@@ -219,8 +351,8 @@ export declare const marcoSDK: {
                     readonly status: import("valibot").LiteralSchema<409, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
                     readonly data: import("valibot").ObjectSchema<{
-                        readonly accessToken: import("valibot").StringSchema<undefined>;
                         readonly refreshToken: import("valibot").StringSchema<undefined>;
+                        readonly accessToken: import("valibot").StringSchema<undefined>;
                         readonly user: import("valibot").ObjectSchema<{
                             readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                             readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RfcEmailAction<string, undefined>]>, undefined>;
@@ -271,12 +403,24 @@ export declare const marcoSDK: {
                 }, undefined>;
                 readonly status: import("valibot").LiteralSchema<404, undefined>;
             }, undefined>;
+            readonly attachmentSizeMismatchErrorSchema: import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"ATTACHMENT_SIZE_MISMATCH", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<400, 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 attachmentUploadFailedErrorSchema: import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"ATTACHMENT_UPLOAD_FAILED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<500, undefined>;
+            }, undefined>;
             readonly authCodeExpiredErrorSchema: import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
                     readonly code: import("valibot").LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;

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

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

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

@@ -77,6 +77,18 @@ export declare const attachmentStateInvalidErrorSchema: v.ObjectSchema<{
     }, undefined>;
     readonly status: v.LiteralSchema<409, undefined>;
 }, undefined>;
+export declare const attachmentSizeMismatchErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"ATTACHMENT_SIZE_MISMATCH", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>;
+export declare const attachmentUploadFailedErrorSchema: v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"ATTACHMENT_UPLOAD_FAILED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<500, undefined>;
+}, undefined>;
 export declare const accountNotFoundErrorSchema: v.ObjectSchema<{
     readonly data: v.ObjectSchema<{
         readonly code: v.LiteralSchema<"ACCOUNT_NOT_FOUND", undefined>;
@@ -179,12 +191,24 @@ export declare const errors: {
         }, undefined>;
         readonly status: v.LiteralSchema<404, undefined>;
     }, undefined>;
+    readonly attachmentSizeMismatchErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"ATTACHMENT_SIZE_MISMATCH", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<400, 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 attachmentUploadFailedErrorSchema: v.ObjectSchema<{
+        readonly data: v.ObjectSchema<{
+            readonly code: v.LiteralSchema<"ATTACHMENT_UPLOAD_FAILED", undefined>;
+        }, undefined>;
+        readonly status: v.LiteralSchema<500, undefined>;
+    }, undefined>;
     readonly authCodeExpiredErrorSchema: v.ObjectSchema<{
         readonly data: v.ObjectSchema<{
             readonly code: v.LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;

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

	@@ -1 +1 @@
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"}
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,iCAAiC;;;;;aAG5C,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BT,CAAA"}

package/dist/sdk/validation/errors.js CHANGED Viewed

@@ -51,6 +51,14 @@ export const attachmentStateInvalidErrorSchema = v.object({
     data: v.object({ code: v.literal('ATTACHMENT_STATE_INVALID') }),
     status: v.literal(409),
 });
+export const attachmentSizeMismatchErrorSchema = v.object({
+    data: v.object({ code: v.literal('ATTACHMENT_SIZE_MISMATCH') }),
+    status: v.literal(400),
+});
+export const attachmentUploadFailedErrorSchema = v.object({
+    data: v.object({ code: v.literal('ATTACHMENT_UPLOAD_FAILED') }),
+    status: v.literal(500),
+});
 export const accountNotFoundErrorSchema = v.object({
     data: v.object({ code: v.literal('ACCOUNT_NOT_FOUND') }),
     status: v.literal(404),
@@ -114,7 +122,9 @@ export const errors = {
     accountNotFoundErrorSchema,
     aliasNotFoundErrorSchema,
     attachmentNotFoundErrorSchema,
+    attachmentSizeMismatchErrorSchema,
     attachmentStateInvalidErrorSchema,
+    attachmentUploadFailedErrorSchema,
     authCodeExpiredErrorSchema,
     authCodeInvalidErrorSchema,
     authCodePreviouslyUsedErrorSchema,