npm - @marcoappio/marco-config - Versions diffs - 7.0.0 → 8.0.0 - Mend

@marcoappio/marco-config 7.0.0 → 8.0.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 (68) hide show

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

@@ -114,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<{
@@ -138,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>;
@@ -229,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>;

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/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@marcoappio/marco-config",
-  "version": "7.0.0",
+  "version": "8.0.0",
   "author": "team@marcoapp.io",
   "main": "dist/index.js",
   "repository": "git@github.com:marcoappio/marco-config.git",

package/dist/sdk/endpoints/private/models/thread/getThreads.d.ts DELETED Viewed

@@ -1,83 +0,0 @@
-import * as v from 'valibot';
-export declare const getThreads: import("../../../../..").EndpointConfig<"/v1/pv/models/threads/full", v.GenericSchema | undefined, v.UnionSchema<[v.ObjectSchema<{
-    readonly ids: v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
-    readonly labelIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-    readonly cursor: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    readonly limit: v.OptionalSchema<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>]>, undefined>;
-    readonly participants: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly ids: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-    readonly labelIds: v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
-    readonly cursor: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
-    readonly limit: v.OptionalSchema<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>]>, undefined>;
-    readonly participants: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, 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<"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 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>;
-        }, undefined>, undefined>;
-        readonly nextCursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=getThreads.d.ts.map

package/dist/sdk/endpoints/private/models/thread/getThreads.d.ts.map DELETED Viewed

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

package/dist/sdk/endpoints/private/models/thread/getThreads.js DELETED Viewed

@@ -1,36 +0,0 @@
-import * as v from 'valibot';
-import { marcoSchemas } from '../../../../../schemas';
-import { paginatedResponseSchema } from '../../../../../schemas/paginatedResponse';
-import { createEndpoint } from '../../../../../sdk/endpoints/createEndpointConfig';
-import { authFailedErrorSchema, userNotFoundErrorSchema, validationFailedErrorSchema, } from '../../../../../sdk/validation/errors';
-const baseQuerySchema = {
-    cursor: v.optional(v.string()),
-    limit: v.optional(marcoSchemas.number.positiveIntegerFromString()),
-    participants: v.optional(v.array(v.string())),
-};
-const getThreadsQuerySchema = v.union([
-    v.object({
-        ...baseQuerySchema,
-        ids: v.pipe(v.array(v.string()), v.minLength(1)),
-        labelIds: v.optional(v.array(v.string())),
-    }),
-    v.object({
-        ...baseQuerySchema,
-        ids: v.optional(v.array(v.string())),
-        labelIds: v.pipe(v.array(v.string()), v.minLength(1)),
-    }),
-]);
-export const getThreads = createEndpoint({
-    method: 'GET',
-    path: '/v1/pv/models/threads/full',
-    query: getThreadsQuerySchema,
-    response: v.union([
-        authFailedErrorSchema,
-        userNotFoundErrorSchema,
-        validationFailedErrorSchema,
-        v.object({
-            data: paginatedResponseSchema(marcoSchemas.models.threadFullSchema),
-            status: v.literal(200),
-        }),
-    ]),
-});