@marcoappio/marco-config 2.0.414 → 2.0.416

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 export { marcoConstants } from './constants';
-export { instantDBPermissions, instantDBSchema } from './instantDB';
 export { MARCO_ENV, MarcoEnvironment, marcoPublicConfig } from './marcoPublicConfig';
 export { marcoSchemas } from './schemas';
 export { marcoSDK } from './sdk';
-export { EndpointConfig, SDKResponse as EndpointResponse } from './types';
-export { accountUtils, stringPatch } from './utils';
+export { EndpointConfig, LabelSpecialUse, SDKError, SDKResponse as EndpointResponse } from './types';
+export { accountUtils, labelUtils, stringPatch } from './utils';
+export { AccountMutatorHandlers, accountMutatorDefinitions, createMutators, DraftMutatorHandlers, draftMutatorDefinitions, MarcoZeroMutatorHandlers, MarcoZeroMutators, MarcoZeroSchema, marcoZero, schema as zeroSchema, ThreadMutatorHandlers, threadMutatorDefinitions, UserMutatorHandlers, userMutatorDefinitions, ZeroMutatorValidationError, zeroMutatorSchemas, zeroTables, } from './zero';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AACnE,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AACpF,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAChC,OAAO,EAAE,cAAc,EAAE,WAAW,IAAI,gBAAgB,EAAE,MAAM,SAAS,CAAA;AACzE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AACpF,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAChC,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,QAAQ,EAAE,WAAW,IAAI,gBAAgB,EAAE,MAAM,SAAS,CAAA;AACpG,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAC/D,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,cAAc,EACd,oBAAoB,EACpB,uBAAuB,EACvB,wBAAwB,EACxB,iBAAiB,EACjB,eAAe,EACf,SAAS,EACT,MAAM,IAAI,UAAU,EACpB,qBAAqB,EACrB,wBAAwB,EACxB,mBAAmB,EACnB,sBAAsB,EACtB,0BAA0B,EAC1B,kBAAkB,EAClB,UAAU,GACX,MAAM,QAAQ,CAAA"}

package/dist/index.js

@@ -1,6 +1,6 @@
 export { marcoConstants } from './constants';
-export { instantDBPermissions, instantDBSchema } from './instantDB';
 export { MARCO_ENV, marcoPublicConfig } from './marcoPublicConfig';
 export { marcoSchemas } from './schemas';
 export { marcoSDK } from './sdk';
-export { accountUtils, stringPatch } from './utils';
+export { accountUtils, labelUtils, stringPatch } from './utils';
+export { accountMutatorDefinitions, createMutators, draftMutatorDefinitions, marcoZero, schema as zeroSchema, threadMutatorDefinitions, userMutatorDefinitions, ZeroMutatorValidationError, zeroMutatorSchemas, zeroTables, } from './zero';

package/dist/marcoPublicConfig.d.ts

@@ -23,6 +23,20 @@ type MarcoPublicConfig = {
             tenantId: string;
         };
     };
+    /**
+     * @deprecated Replicache support is being removed in favor of Zero.
+     * Downstream consumers should migrate to `zero`.
+     */
+    replicache?: {
+        licenseKey: string;
+    };
+    zero: {
+        cacheUrl: string;
+        pushUrl: string;
+    };
+    workOS: {
+        clientId: string;
+    };
 };
 export declare const marcoPublicConfig: (env?: MarcoEnvironment) => MarcoPublicConfig;
 export {};

package/dist/marcoPublicConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"marcoPublicConfig.d.ts","sourceRoot":"","sources":["../src/marcoPublicConfig.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAAG,SAAS,GAAG,aAAa,CAAA;AAEvE,eAAO,MAAM,SAAS,kBAGP,CAAA;AAEf,KAAK,iBAAiB,GAAG;IACvB,KAAK,EAAE;QACL,GAAG,EAAE;YACH,OAAO,EAAE,MAAM,CAAA;SAChB,CAAA;QACD,GAAG,EAAE;YACH,OAAO,EAAE,MAAM,CAAA;SAChB,CAAA;QACD,EAAE,EAAE;YACF,KAAK,EAAE,MAAM,CAAA;YACb,IAAI,EAAE,MAAM,CAAA;YACZ,GAAG,EAAE,MAAM,CAAA;SACZ,CAAA;KACF,CAAA;IACD,KAAK,EAAE;QACL,MAAM,EAAE;YACN,QAAQ,EAAE,MAAM,CAAA;SACjB,CAAA;QACD,OAAO,EAAE;YACP,QAAQ,EAAE,MAAM,CAAA;YAChB,QAAQ,EAAE,MAAM,CAAA;SACjB,CAAA;KACF,CAAA;CACF,CAAA;AA6ED,eAAO,MAAM,iBAAiB,SAAS,gBAAgB,sBAAmC,CAAA"}
+{"version":3,"file":"marcoPublicConfig.d.ts","sourceRoot":"","sources":["../src/marcoPublicConfig.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAAG,SAAS,GAAG,aAAa,CAAA;AAEvE,eAAO,MAAM,SAAS,kBAGP,CAAA;AAEf,KAAK,iBAAiB,GAAG;IACvB,KAAK,EAAE;QACL,GAAG,EAAE;YACH,OAAO,EAAE,MAAM,CAAA;SAChB,CAAA;QACD,GAAG,EAAE;YACH,OAAO,EAAE,MAAM,CAAA;SAChB,CAAA;QACD,EAAE,EAAE;YACF,KAAK,EAAE,MAAM,CAAA;YACb,IAAI,EAAE,MAAM,CAAA;YACZ,GAAG,EAAE,MAAM,CAAA;SACZ,CAAA;KACF,CAAA;IACD,KAAK,EAAE;QACL,MAAM,EAAE;YACN,QAAQ,EAAE,MAAM,CAAA;SACjB,CAAA;QACD,OAAO,EAAE;YACP,QAAQ,EAAE,MAAM,CAAA;YAChB,QAAQ,EAAE,MAAM,CAAA;SACjB,CAAA;KACF,CAAA;IACD;;;OAGG;IACH,UAAU,CAAC,EAAE;QACX,UAAU,EAAE,MAAM,CAAA;KACnB,CAAA;IACD,IAAI,EAAE;QACJ,QAAQ,EAAE,MAAM,CAAA;QAChB,OAAO,EAAE,MAAM,CAAA;KAChB,CAAA;IACD,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,CAAA;KACjB,CAAA;CACF,CAAA;AA2GD,eAAO,MAAM,iBAAiB,SAAS,gBAAgB,sBAAmC,CAAA"}

package/dist/marcoPublicConfig.js

@@ -25,6 +25,16 @@ const configMap = {
                 tenantId: '33fe2afe-644d-4fe2-a264-c4f2c34fa2cf',
             },
         },
+        replicache: {
+            licenseKey: 'la6cf85ee37b5495481575ecececc3e49',
+        },
+        workOS: {
+            clientId: 'client_01J51ET6KV4GBGMGHY0PJ9VGP2',
+        },
+        zero: {
+            cacheUrl: 'https://zero.staging.marcoapp.io',
+            pushUrl: 'https://api.staging.marcoapp.io/v1/zero/push',
+        },
     },
     production: {
         marco: {
@@ -49,6 +59,16 @@ const configMap = {
                 tenantId: '33fe2afe-644d-4fe2-a264-c4f2c34fa2cf',
             },
         },
+        replicache: {
+            licenseKey: 'la6cf85ee37b5495481575ecececc3e49',
+        },
+        workOS: {
+            clientId: 'client_01J51ET6RT5WCS3NNQYBB7FAE7',
+        },
+        zero: {
+            cacheUrl: 'https://zero.marcoapp.io',
+            pushUrl: 'https://api.marcoapp.io/v1/zero/push',
+        },
     },
     staging: {
         marco: {
@@ -73,6 +93,16 @@ const configMap = {
                 tenantId: '33fe2afe-644d-4fe2-a264-c4f2c34fa2cf',
             },
         },
+        replicache: {
+            licenseKey: 'la6cf85ee37b5495481575ecececc3e49',
+        },
+        workOS: {
+            clientId: 'client_01J51ET6KV4GBGMGHY0PJ9VGP2',
+        },
+        zero: {
+            cacheUrl: 'https://zero.staging.marcoapp.io',
+            pushUrl: 'https://api.staging.marcoapp.io/v1/zero/push',
+        },
     },
 };
 export const marcoPublicConfig = (env = 'development') => configMap[env];

package/dist/schemas/app.d.ts

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
 export declare const app: {
-    platform: () => v.UnionSchema<[v.LiteralSchema<"ios", undefined>, v.LiteralSchema<"osx", undefined>, v.LiteralSchema<"web", undefined>], undefined>;
+    platform: () => v.PicklistSchema<readonly ["ios", "osx", "web"], undefined>;
 };
 //# sourceMappingURL=app.d.ts.map

package/dist/schemas/app.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../src/schemas/app.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,GAAG;;CAEf,CAAA"}
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../src/schemas/app.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B,eAAO,MAAM,GAAG;;CAEf,CAAA"}

package/dist/schemas/app.js

@@ -1,4 +1,5 @@
 import * as v from 'valibot';
+import { MARCO_PLATFORM } from '../types';
 export const app = {
-    platform: () => v.union([v.literal('ios'), v.literal('osx'), v.literal('web')]),
+    platform: () => v.picklist(MARCO_PLATFORM),
 };

package/dist/schemas/emailAccount.d.ts

@@ -14,7 +14,7 @@ export declare const emailAccount: {
     }, undefined>;
     connectionConfigOauth: () => v.ObjectSchema<{
         readonly code: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly provider: v.UnionSchema<[v.LiteralSchema<"GOOGLE", undefined>, v.LiteralSchema<"OUTLOOK", undefined>], undefined>;
+        readonly provider: v.PicklistSchema<readonly ["GOOGLE", "OUTLOOK"], undefined>;
         readonly user: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
     }, undefined>;
     imapConnectionStatus: () => v.PicklistSchema<readonly ["AWAITING_CONNECTION", "CONNECTED", "CONNECTION_FAILED_AUTHENTICATION_ERROR", "CONNECTION_FAILED_CONNECTION_ERROR", "CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR", "CONNECTION_FAILED_QUOTA_ERROR", "CONNECTION_FAILED_UNKNOWN_ERROR"], undefined>;

package/dist/schemas/index.d.ts

@@ -1,6 +1,6 @@
 export declare const marcoSchemas: {
     app: {
-        platform: () => import("valibot").UnionSchema<[import("valibot").LiteralSchema<"ios", undefined>, import("valibot").LiteralSchema<"osx", undefined>, import("valibot").LiteralSchema<"web", undefined>], undefined>;
+        platform: () => import("valibot").PicklistSchema<readonly ["ios", "osx", "web"], undefined>;
     };
     auth: {
         code: import("valibot").ObjectSchema<{
@@ -43,7 +43,7 @@ export declare const marcoSchemas: {
         }, undefined>;
         connectionConfigOauth: () => import("valibot").ObjectSchema<{
             readonly code: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly provider: import("valibot").UnionSchema<[import("valibot").LiteralSchema<"GOOGLE", undefined>, import("valibot").LiteralSchema<"OUTLOOK", undefined>], undefined>;
+            readonly provider: import("valibot").PicklistSchema<readonly ["GOOGLE", "OUTLOOK"], undefined>;
             readonly user: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
         }, undefined>;
         imapConnectionStatus: () => import("valibot").PicklistSchema<readonly ["AWAITING_CONNECTION", "CONNECTED", "CONNECTION_FAILED_AUTHENTICATION_ERROR", "CONNECTION_FAILED_CONNECTION_ERROR", "CONNECTION_FAILED_OAUTH_EXCHANGE_ERROR", "CONNECTION_FAILED_QUOTA_ERROR", "CONNECTION_FAILED_UNKNOWN_ERROR"], undefined>;
@@ -57,7 +57,7 @@ export declare const marcoSchemas: {
         positiveInteger: () => import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
     };
     oauth: {
-        provider: () => import("valibot").UnionSchema<[import("valibot").LiteralSchema<"GOOGLE", undefined>, import("valibot").LiteralSchema<"OUTLOOK", undefined>], undefined>;
+        provider: () => import("valibot").PicklistSchema<readonly ["GOOGLE", "OUTLOOK"], undefined>;
     };
     pushNotifications: {
         payload: import("valibot").UnionSchema<[import("valibot").ObjectSchema<{

package/dist/schemas/oauth.d.ts

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
 export declare const oauth: {
-    provider: () => v.UnionSchema<[v.LiteralSchema<"GOOGLE", undefined>, v.LiteralSchema<"OUTLOOK", undefined>], undefined>;
+    provider: () => v.PicklistSchema<readonly ["GOOGLE", "OUTLOOK"], undefined>;
 };
 //# sourceMappingURL=oauth.d.ts.map

package/dist/schemas/oauth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../src/schemas/oauth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,KAAK;;CAEjB,CAAA"}
+{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../src/schemas/oauth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B,eAAO,MAAM,KAAK;;CAEjB,CAAA"}

package/dist/schemas/oauth.js

@@ -1,4 +1,5 @@
 import * as v from 'valibot';
+import { OAUTH_PROVIDERS } from '../types';
 export const oauth = {
-    provider: () => v.union([v.literal('GOOGLE'), v.literal('OUTLOOK')]),
+    provider: () => v.picklist(OAUTH_PROVIDERS),
 };

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

@@ -1,7 +1,193 @@
 import type { GenericSchema } from 'valibot';
 import type { EndpointConfig } from '../../types';
 export declare const endpoints: {
+    private: {
+        emailMessage: {
+            getAttachment: EndpointConfig<"/v1/pv/attachment/:attachmentId", GenericSchema | undefined, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"ATTACHMENT_NOT_FOUND", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<404, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"ATTACHMENT_STATE_INVALID", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<409, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly file: import("valibot").NonOptionalSchema<import("valibot").FileSchema<undefined>, undefined>;
+                readonly status: import("valibot").LiteralSchema<200, undefined>;
+            }, undefined>], undefined>>;
+            getHTML: EndpointConfig<"/v1/pv/message/:messageId/html", GenericSchema | undefined, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<404, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly content: import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").StringSchema<undefined>, undefined>;
+                    readonly html: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<200, undefined>;
+            }, undefined>], undefined>>;
+        };
+        user: {
+            deleteUser: EndpointConfig<"/v1/pv/user", GenericSchema | undefined, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly status: import("valibot").LiteralSchema<204, undefined>;
+            }, undefined>], undefined>>;
+        };
+    };
     public: {
+        auth: {
+            refreshAuth: 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>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                    readonly issues: import("valibot").ObjectSchema<{
+                        readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                        readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                    }, undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<400, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTH_REFRESH_TOKEN_INVALID", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<502, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly accessToken: import("valibot").StringSchema<undefined>;
+                    readonly refreshToken: import("valibot").StringSchema<undefined>;
+                    readonly user: import("valibot").ObjectSchema<{
+                        readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        readonly emailVerified: import("valibot").BooleanSchema<undefined>;
+                        readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly profilePictureUrl: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                    }, undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<200, undefined>;
+            }, undefined>], undefined>>;
+            sendAuthCode: EndpointConfig<"/v1/pb/auth/send-code", import("valibot").ObjectSchema<{
+                readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+            }, undefined>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                    readonly issues: import("valibot").ObjectSchema<{
+                        readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                        readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                    }, undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<400, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<502, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"INVITE_NOT_FOUND", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<404, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly status: import("valibot").LiteralSchema<200, undefined>;
+            }, undefined>], undefined>>;
+            verifyAuthCode: EndpointConfig<"/v1/pb/auth/verify-code", import("valibot").UnionSchema<[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").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly authType: import("valibot").LiteralSchema<"PASSWORD", undefined>;
+                readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                readonly password: import("valibot").StringSchema<undefined>;
+            }, undefined>], undefined>, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
+                    readonly issues: import("valibot").ObjectSchema<{
+                        readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+                        readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                    }, undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<400, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTH_CODE_EXPIRED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTH_CODE_INVALID", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTH_CODE_PREVIOUSLY_USED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTH_TOO_MANY_ATTEMPTS", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<401, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"AUTH_SERVER_RESPONSE_UNEXPECTED", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<502, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"USER_NOT_FOUND", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<404, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"USER_MARKED_FOR_DELETION", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<409, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly accessToken: import("valibot").StringSchema<undefined>;
+                    readonly refreshToken: import("valibot").StringSchema<undefined>;
+                    readonly user: import("valibot").ObjectSchema<{
+                        readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly email: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").EmailAction<string, undefined>, import("valibot").MaxLengthAction<string, 255, undefined>]>, undefined>;
+                        readonly emailVerified: import("valibot").BooleanSchema<undefined>;
+                        readonly firstName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly id: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly lastName: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly profilePictureUrl: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                        readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+                    }, undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<200, undefined>;
+            }, undefined>], undefined>>;
+        };
         config: EndpointConfig<"/v1/pb/config", GenericSchema | undefined, GenericSchema | undefined, import("valibot").ObjectSchema<{
             readonly data: import("valibot").ObjectSchema<{
                 readonly app: import("valibot").ObjectSchema<{

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/endpoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5C,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,qBAAqB,CAAA;AAUtE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;CAEM,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/endpoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5C,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,qBAAqB,CAAA;AAWtE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGM,CAAA"}

package/dist/sdk/endpoints/index.js

@@ -1,4 +1,6 @@
+import { privateGroup } from './private';
 import { publicGroup } from './public';
 export const endpoints = {
+    private: privateGroup,
     public: publicGroup,
 };

package/dist/sdk/endpoints/private/emailMessage/getEmailMessageAttachment.d.ts

@@ -0,0 +1,21 @@
+import * as v from 'valibot';
+export declare const getEmailMessageAttachment: import("../../../..").EndpointConfig<"/v1/pv/attachment/:attachmentId", v.GenericSchema | undefined, v.GenericSchema | 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<"ATTACHMENT_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly code: v.LiteralSchema<"ATTACHMENT_STATE_INVALID", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<409, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly file: v.NonOptionalSchema<v.FileSchema<undefined>, undefined>;
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=getEmailMessageAttachment.d.ts.map

package/dist/sdk/endpoints/private/emailMessage/getEmailMessageAttachment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getEmailMessageAttachment.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/emailMessage/getEmailMessageAttachment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAS5B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;2BAYpC,CAAA"}

package/dist/sdk/endpoints/private/emailMessage/getEmailMessageAttachment.js

@@ -0,0 +1,16 @@
+import * as v from 'valibot';
+import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
+import { attachmentNotFoundErrorSchema, attachmentStateInvalidErrorSchema, authFailedErrorSchema, } from '../../../../sdk/validation/errors';
+export const getEmailMessageAttachment = createEndpoint({
+    method: 'GET',
+    path: '/v1/pv/attachment/:attachmentId',
+    response: v.union([
+        authFailedErrorSchema,
+        attachmentNotFoundErrorSchema,
+        attachmentStateInvalidErrorSchema,
+        v.object({
+            file: v.nonOptional(v.file()),
+            status: v.literal(200),
+        }),
+    ]),
+});

package/dist/sdk/endpoints/private/emailMessage/getEmailMessageHTML.d.ts

@@ -0,0 +1,19 @@
+import * as v from 'valibot';
+export declare const getEmailMessageHTML: import("../../../..").EndpointConfig<"/v1/pv/message/:messageId/html", v.GenericSchema | undefined, v.GenericSchema | 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<"MESSAGE_NOT_FOUND", undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<404, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly content: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
+        readonly html: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=getEmailMessageHTML.d.ts.map

package/dist/sdk/endpoints/private/emailMessage/getEmailMessageHTML.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getEmailMessageHTML.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/emailMessage/getEmailMessageHTML.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;2BAc9B,CAAA"}

package/dist/sdk/endpoints/private/emailMessage/getEmailMessageHTML.js

@@ -0,0 +1,19 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../../../../schemas';
+import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
+import { authFailedErrorSchema, messageNotFoundErrorSchema } from '../../../../sdk/validation/errors';
+export const getEmailMessageHTML = createEndpoint({
+    method: 'GET',
+    path: '/v1/pv/message/:messageId/html',
+    response: v.union([
+        authFailedErrorSchema,
+        messageNotFoundErrorSchema,
+        v.object({
+            data: v.object({
+                content: v.record(v.string(), v.string()),
+                html: marcoSchemas.string.required(),
+            }),
+            status: v.literal(200),
+        }),
+    ]),
+});

package/dist/sdk/endpoints/private/emailMessage/index.d.ts

@@ -0,0 +1,39 @@
+export declare const emailMessage: {
+    getAttachment: import("../../../..").EndpointConfig<"/v1/pv/attachment/:attachmentId", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+        readonly data: import("valibot").ObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<401, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly data: import("valibot").ObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"ATTACHMENT_NOT_FOUND", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<404, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly data: import("valibot").ObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"ATTACHMENT_STATE_INVALID", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<409, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly file: import("valibot").NonOptionalSchema<import("valibot").FileSchema<undefined>, undefined>;
+        readonly status: import("valibot").LiteralSchema<200, undefined>;
+    }, undefined>], undefined>>;
+    getHTML: import("../../../..").EndpointConfig<"/v1/pv/message/:messageId/html", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+        readonly data: import("valibot").ObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<401, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly data: import("valibot").ObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<404, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly data: import("valibot").ObjectSchema<{
+            readonly content: import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").StringSchema<undefined>, undefined>;
+            readonly html: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<200, undefined>;
+    }, undefined>], undefined>>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/sdk/endpoints/private/emailMessage/index.d.ts.map

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

package/dist/sdk/endpoints/private/emailMessage/index.js

@@ -0,0 +1,6 @@
+import { getEmailMessageAttachment } from './getEmailMessageAttachment';
+import { getEmailMessageHTML } from './getEmailMessageHTML';
+export const emailMessage = {
+    getAttachment: getEmailMessageAttachment,
+    getHTML: getEmailMessageHTML,
+};

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

@@ -0,0 +1,51 @@
+export declare const privateGroup: {
+    emailMessage: {
+        getAttachment: import("../../..").EndpointConfig<"/v1/pv/attachment/:attachmentId", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<401, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"ATTACHMENT_NOT_FOUND", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<404, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"ATTACHMENT_STATE_INVALID", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<409, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly file: import("valibot").NonOptionalSchema<import("valibot").FileSchema<undefined>, undefined>;
+            readonly status: import("valibot").LiteralSchema<200, undefined>;
+        }, undefined>], undefined>>;
+        getHTML: import("../../..").EndpointConfig<"/v1/pv/message/:messageId/html", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<401, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"MESSAGE_NOT_FOUND", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<404, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly content: import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").StringSchema<undefined>, undefined>;
+                readonly html: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<200, undefined>;
+        }, undefined>], undefined>>;
+    };
+    user: {
+        deleteUser: import("../../..").EndpointConfig<"/v1/pv/user", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<401, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly status: import("valibot").LiteralSchema<204, undefined>;
+        }, undefined>], undefined>>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

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