@marcoappio/marco-config 7.0.0 → 8.0.0

package/dist/sdk/endpoints/private/models/thread/getThreadByMessageId.d.ts

@@ -15,48 +15,23 @@ export declare const getThreadByMessageId: import("../../../../..").EndpointConf
     }, undefined>;
     readonly status: v.LiteralSchema<404, undefined>;
 }, undefined>, v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly messages: v.ArraySchema<v.ObjectSchema<{
-            readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>;
-            readonly attachments: v.ArraySchema<v.ObjectSchema<{
-                readonly fileName: v.NonOptionalSchema<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>, v.BrandAction<string, "AttachmentId">]>, undefined>;
-                readonly mimeType: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly size: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-                readonly threadMessageId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "MessageId">]>, undefined>;
-            }, undefined>, undefined>;
-            readonly envelopeDate: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-            readonly envelopeSubject: 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>, v.BrandAction<string, "MessageId">]>, undefined>;
-            readonly previewText: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly recipients: v.ArraySchema<v.ObjectSchema<{
-                readonly emailAddress: v.NonOptionalSchema<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>, v.BrandAction<string, "RecipientId">]>, undefined>;
-                readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-                readonly threadMessageId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "MessageId">]>, undefined>;
-                readonly type: v.PicklistSchema<readonly ["bcc", "cc", "to", "replyTo"], undefined>;
-            }, undefined>, undefined>;
-            readonly senderEmail: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly senderName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>;
-            readonly unsubscribeUrl: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>, undefined>;
-        readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>;
-        readonly flagged: v.BooleanSchema<undefined>;
-        readonly hasAttachments: v.BooleanSchema<undefined>;
-        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>;
-        readonly labelIdList: v.StringSchema<undefined>;
-        readonly latestMessageDate: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-        readonly latestMessageId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "MessageId">]>, undefined>;
-        readonly messageCount: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-        readonly previewText: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly seen: v.BooleanSchema<undefined>;
-        readonly senderEmail: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly senderName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly snoozedUntil: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
-        readonly subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly userId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "UserId">]>, undefined>;
-        readonly words: v.StringSchema<undefined>;
+    readonly data: v.StrictObjectSchema<{
+        accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>;
+        flagged: v.BooleanSchema<undefined>;
+        hasAttachments: v.BooleanSchema<undefined>;
+        id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>;
+        labelIdList: v.StringSchema<undefined>;
+        latestMessageDate: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        latestMessageId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "MessageId">]>, undefined>;
+        messageCount: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        previewText: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        seen: v.BooleanSchema<undefined>;
+        senderEmail: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        senderName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        snoozedUntil: v.NullableSchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>, undefined>;
+        subject: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        userId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "UserId">]>, undefined>;
+        words: v.StringSchema<undefined>;
     }, undefined>;
     readonly status: v.LiteralSchema<200, undefined>;
 }, undefined>], undefined>>;

package/dist/sdk/endpoints/private/models/thread/getThreadByMessageId.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getThreadByMessageId.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/thread/getThreadByMessageId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAU5B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAY/B,CAAA"}
+{"version":3,"file":"getThreadByMessageId.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/thread/getThreadByMessageId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAU5B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAY/B,CAAA"}

package/dist/sdk/endpoints/private/models/thread/getThreadByMessageId.js

@@ -10,7 +10,7 @@ export const getThreadByMessageId = createEndpoint({
         userNotFoundErrorSchema,
         messageNotFoundErrorSchema,
         v.object({
-            data: marcoSchemas.models.threadFullSchema,
+            data: marcoSchemas.models.threadSchema,
             status: v.literal(200),
         }),
     ]),

package/dist/sdk/endpoints/private/models/thread/getThreadList.d.ts

@@ -54,7 +54,7 @@ export declare const getThreadList: import("../../../../..").EndpointConfig<"/v1
     readonly status: v.LiteralSchema<400, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly data: v.ObjectSchema<{
-        readonly items: v.ArraySchema<v.ObjectSchema<{
+        readonly items: v.ArraySchema<v.StrictObjectSchema<{
             accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>;
             flagged: v.BooleanSchema<undefined>;
             hasAttachments: v.BooleanSchema<undefined>;

package/dist/sdk/endpoints/private/models/thread/getThreadMessageAttachments.d.ts

@@ -0,0 +1,43 @@
+import * as v from 'valibot';
+export declare const getThreadMessageAttachments: import("../../../../..").EndpointConfig<"/v1/pv/models/thread-message/:messageId/attachments", v.GenericSchema | undefined, v.ObjectSchema<{
+    readonly cursor: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 512, undefined>]>, undefined>;
+    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.TransformAction<string, number>, v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 1000, undefined>]>, undefined>;
+}, undefined>, v.UnionSchema<[v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+        readonly issues: v.ObjectSchema<{
+            readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+            readonly other: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly items: v.ArraySchema<v.ObjectSchema<{
+            readonly fileName: v.NonOptionalSchema<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>, v.BrandAction<string, "AttachmentId">]>, undefined>;
+            readonly mimeType: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly size: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly threadMessageId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "MessageId">]>, undefined>;
+        }, undefined>, undefined>;
+        readonly nextCursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=getThreadMessageAttachments.d.ts.map

package/dist/sdk/endpoints/private/models/thread/getThreadMessageAttachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getThreadMessageAttachments.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/thread/getThreadMessageAttachments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAc5B,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BActC,CAAA"}

package/dist/sdk/endpoints/private/models/thread/getThreadMessageAttachments.js

@@ -0,0 +1,21 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../../../../../schemas';
+import { paginatedResponseSchema } from '../../../../../schemas/paginatedResponse';
+import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
+import { authFailedErrorSchema, messageNotFoundErrorSchema, userNotFoundErrorSchema, validationFailedErrorSchema, } from '../../../../../sdk/validation/errors';
+import { threadDetailPaginationQuerySchema } from './threadDetailPagination';
+export const getThreadMessageAttachments = createEndpoint({
+    method: 'GET',
+    path: '/v1/pv/models/thread-message/:messageId/attachments',
+    query: threadDetailPaginationQuerySchema,
+    response: v.union([
+        authFailedErrorSchema,
+        userNotFoundErrorSchema,
+        messageNotFoundErrorSchema,
+        validationFailedErrorSchema,
+        v.object({
+            data: paginatedResponseSchema(marcoSchemas.models.threadMessageAttachmentSchema),
+            status: v.literal(200),
+        }),
+    ]),
+});

package/dist/sdk/endpoints/private/models/thread/getThreadMessageRecipients.d.ts

@@ -0,0 +1,43 @@
+import * as v from 'valibot';
+export declare const getThreadMessageRecipients: import("../../../../..").EndpointConfig<"/v1/pv/models/thread-message/:messageId/recipients", v.GenericSchema | undefined, v.ObjectSchema<{
+    readonly cursor: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 512, undefined>]>, undefined>;
+    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.TransformAction<string, number>, v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 1000, undefined>]>, undefined>;
+}, undefined>, v.UnionSchema<[v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+        readonly issues: v.ObjectSchema<{
+            readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+            readonly other: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly items: v.ArraySchema<v.ObjectSchema<{
+            readonly emailAddress: v.NonOptionalSchema<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>, v.BrandAction<string, "RecipientId">]>, undefined>;
+            readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly threadMessageId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "MessageId">]>, undefined>;
+            readonly type: v.PicklistSchema<readonly ["bcc", "cc", "to", "replyTo"], undefined>;
+        }, undefined>, undefined>;
+        readonly nextCursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=getThreadMessageRecipients.d.ts.map

package/dist/sdk/endpoints/private/models/thread/getThreadMessageRecipients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getThreadMessageRecipients.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/thread/getThreadMessageRecipients.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAc5B,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAcrC,CAAA"}

package/dist/sdk/endpoints/private/models/thread/getThreadMessageRecipients.js

@@ -0,0 +1,21 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../../../../../schemas';
+import { paginatedResponseSchema } from '../../../../../schemas/paginatedResponse';
+import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
+import { authFailedErrorSchema, messageNotFoundErrorSchema, userNotFoundErrorSchema, validationFailedErrorSchema, } from '../../../../../sdk/validation/errors';
+import { threadDetailPaginationQuerySchema } from './threadDetailPagination';
+export const getThreadMessageRecipients = createEndpoint({
+    method: 'GET',
+    path: '/v1/pv/models/thread-message/:messageId/recipients',
+    query: threadDetailPaginationQuerySchema,
+    response: v.union([
+        authFailedErrorSchema,
+        userNotFoundErrorSchema,
+        messageNotFoundErrorSchema,
+        validationFailedErrorSchema,
+        v.object({
+            data: paginatedResponseSchema(marcoSchemas.models.threadMessageRecipientSchema),
+            status: v.literal(200),
+        }),
+    ]),
+});

package/dist/sdk/endpoints/private/models/thread/getThreadMessages.d.ts

@@ -0,0 +1,47 @@
+import * as v from 'valibot';
+export declare const getThreadMessages: import("../../../../..").EndpointConfig<"/v1/pv/models/thread/:threadId/messages", v.GenericSchema | undefined, v.ObjectSchema<{
+    readonly cursor: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 512, undefined>]>, undefined>;
+    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.TransformAction<string, number>, v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 1000, undefined>]>, undefined>;
+}, undefined>, v.UnionSchema<[v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"USER_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"THREAD_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+        readonly issues: v.ObjectSchema<{
+            readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+            readonly other: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly items: v.ArraySchema<v.ObjectSchema<{
+            readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "AccountId">]>, undefined>;
+            readonly envelopeDate: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+            readonly envelopeSubject: 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>, v.BrandAction<string, "MessageId">]>, undefined>;
+            readonly previewText: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly senderEmail: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly senderName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly threadId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "ThreadId">]>, undefined>;
+            readonly unsubscribeUrl: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>, undefined>;
+        readonly nextCursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=getThreadMessages.d.ts.map

package/dist/sdk/endpoints/private/models/thread/getThreadMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getThreadMessages.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/thread/getThreadMessages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAc5B,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAc5B,CAAA"}

package/dist/sdk/endpoints/private/models/thread/getThreadMessages.js

@@ -0,0 +1,21 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../../../../../schemas';
+import { paginatedResponseSchema } from '../../../../../schemas/paginatedResponse';
+import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
+import { authFailedErrorSchema, threadNotFoundErrorSchema, userNotFoundErrorSchema, validationFailedErrorSchema, } from '../../../../../sdk/validation/errors';
+import { threadDetailPaginationQuerySchema } from './threadDetailPagination';
+export const getThreadMessages = createEndpoint({
+    method: 'GET',
+    path: '/v1/pv/models/thread/:threadId/messages',
+    query: threadDetailPaginationQuerySchema,
+    response: v.union([
+        authFailedErrorSchema,
+        userNotFoundErrorSchema,
+        threadNotFoundErrorSchema,
+        validationFailedErrorSchema,
+        v.object({
+            data: paginatedResponseSchema(marcoSchemas.models.threadMessageSchema),
+            status: v.literal(200),
+        }),
+    ]),
+});

package/dist/sdk/endpoints/private/models/thread/index.d.ts

@@ -1,5 +1,7 @@
 export { getThread } from './getThread';
 export { getThreadByMessageId } from './getThreadByMessageId';
 export { getThreadList } from './getThreadList';
-export { getThreads } from './getThreads';
+export { getThreadMessageAttachments } from './getThreadMessageAttachments';
+export { getThreadMessageRecipients } from './getThreadMessageRecipients';
+export { getThreadMessages } from './getThreadMessages';
 //# sourceMappingURL=index.d.ts.map

package/dist/sdk/endpoints/private/models/thread/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/thread/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/thread/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAA;AAC3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAA;AACzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/sdk/endpoints/private/models/thread/index.js

@@ -1,4 +1,6 @@
 export { getThread } from './getThread';
 export { getThreadByMessageId } from './getThreadByMessageId';
 export { getThreadList } from './getThreadList';
-export { getThreads } from './getThreads';
+export { getThreadMessageAttachments } from './getThreadMessageAttachments';
+export { getThreadMessageRecipients } from './getThreadMessageRecipients';
+export { getThreadMessages } from './getThreadMessages';

package/dist/sdk/endpoints/private/models/thread/threadDetailPagination.d.ts

@@ -0,0 +1,6 @@
+import * as v from 'valibot';
+export declare const threadDetailPaginationQuerySchema: v.ObjectSchema<{
+    readonly cursor: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, 512, undefined>]>, undefined>;
+    readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.TransformAction<string, number>, v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 1000, undefined>]>, undefined>;
+}, undefined>;
+//# sourceMappingURL=threadDetailPagination.d.ts.map

package/dist/sdk/endpoints/private/models/thread/threadDetailPagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"threadDetailPagination.d.ts","sourceRoot":"","sources":["../../../../../../src/sdk/endpoints/private/models/thread/threadDetailPagination.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,iCAAiC;;;aAK5C,CAAA"}

package/dist/sdk/endpoints/private/models/thread/threadDetailPagination.js

@@ -0,0 +1,7 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../../../../../schemas';
+const MAXIMUM_PAGE_SIZE = 1000;
+export const threadDetailPaginationQuerySchema = v.object({
+    cursor: v.optional(v.pipe(v.string(), v.nonEmpty(), v.maxLength(512))),
+    limit: v.optional(v.pipe(marcoSchemas.number.positiveIntegerFromString(), v.minValue(1), v.maxValue(MAXIMUM_PAGE_SIZE))),
+});

package/dist/sdk/endpoints/public/auth/browser/deleteSession.d.ts

@@ -0,0 +1,17 @@
+import * as v from 'valibot';
+export declare const deleteSession: import("../../../../..").EndpointConfig<"/v1/pb/auth/browser/session", v.GenericSchema | undefined, v.StrictObjectSchema<{
+    readonly sessionGeneration: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+}, undefined>, v.UnionSchema<[v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+        readonly issues: v.ObjectSchema<{
+            readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+            readonly other: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly status: v.LiteralSchema<204, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=deleteSession.d.ts.map

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

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

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

@@ -0,0 +1,14 @@
+import * as v from 'valibot';
+import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
+import { browserAuthQuerySchema, browserErrorSchemas } from '../../../../../sdk/endpoints/public/auth/browser/schemas';
+export const deleteSession = createEndpoint({
+    method: 'DELETE',
+    path: '/v1/pb/auth/browser/session',
+    query: browserAuthQuerySchema,
+    response: v.union([
+        browserErrorSchemas.validationFailed,
+        v.strictObject({
+            status: v.literal(204),
+        }),
+    ]),
+});

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

@@ -0,0 +1,123 @@
+export declare const 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>>;
+};
+//# sourceMappingURL=index.d.ts.map

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

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

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

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

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

@@ -0,0 +1,40 @@
+import * as v from 'valibot';
+export declare const refreshAuth: import("../../../../..").EndpointConfig<"/v1/pb/auth/browser/refresh", v.GenericSchema | undefined, v.StrictObjectSchema<{
+    readonly sessionGeneration: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UuidAction<string, undefined>]>;
+}, undefined>, v.UnionSchema<[v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
+        readonly issues: v.ObjectSchema<{
+            readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+            readonly other: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<401, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        readonly code: v.LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<502, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly data: v.StrictObjectSchema<{
+        accessToken: v.StringSchema<undefined>;
+        user: v.ObjectSchema<{
+            readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly email: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>;
+            readonly emailVerified: v.BooleanSchema<undefined>;
+            readonly firstName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly lastName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly profilePictureUrl: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+            readonly updatedAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=refreshAuth.d.ts.map