@marcoappio/marco-config 4.0.26 → 6.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../src/schemas/number.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,6BAA6B,CAAA;AAI/C,eAAO,MAAM,MAAM;IACjB,MAAM,QAAQ,MAAM,OAAO,MAAM;IACjC,kBAAkB;IAClB,eAAe;CAChB,CAAA"}
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../src/schemas/number.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,MAAM;;kBASH,MAAM,OAAO,MAAM;;;;CAIlC,CAAA"}

package/dist/schemas/number.js

@@ -1,7 +1,8 @@
-import { v } from '../utils/valibot/index.js';
-import { nonNegativeIntegerSchema, positiveIntegerSchema } from './scalars.js';
+import * as v from 'valibot';
 export const number = {
+    fromString: () => v.pipe(v.string(), v.nonEmpty(), v.transform(value => Number(value)), v.number(), v.finite()),
     minMax: (min, max) => v.nonOptional(v.pipe(v.number(), v.minValue(min), v.maxValue(max))),
-    nonNegativeInteger: () => v.nonOptional(nonNegativeIntegerSchema),
-    positiveInteger: () => v.nonOptional(positiveIntegerSchema),
+    nullable: () => v.nullable(v.number()),
+    positiveInteger: () => v.nonOptional(v.pipe(v.number(), v.integer(), v.minValue(0))),
+    positiveIntegerFromString: () => v.pipe(number.fromString(), v.integer(), v.minValue(0)),
 };

package/dist/schemas/oauth.d.ts

@@ -1,5 +1,5 @@
-import { v } from '../utils/valibot/index.js';
+import * as v from 'valibot';
 export declare const oauth: {
-    provider: v.PicklistSchema<readonly ["GOOGLE", "OUTLOOK"], 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,EAAE,CAAC,EAAE,MAAM,6BAA6B,CAAA;AAI/C,eAAO,MAAM,KAAK;IAChB,QAAQ;CACT,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,5 +1,5 @@
-import { v } from '../utils/valibot/index.js';
-import { OAUTH_PROVIDERS } from '../types/index.js';
+import * as v from 'valibot';
+import { OAUTH_PROVIDERS } from '../types';
 export const oauth = {
-    provider: v.picklist(OAUTH_PROVIDERS),
+    provider: () => v.picklist(OAUTH_PROVIDERS),
 };

package/dist/schemas/paginatedResponse.d.ts

@@ -0,0 +1,10 @@
+import * as v from 'valibot';
+export declare const paginatedResponseSchema: <T extends v.GenericSchema>(itemSchema: T) => v.ObjectSchema<{
+    readonly items: v.ArraySchema<T, undefined>;
+    readonly nextCursor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type PaginatedResponse<T> = {
+    items: T[];
+    nextCursor: string | null;
+};
+//# sourceMappingURL=paginatedResponse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paginatedResponse.d.ts","sourceRoot":"","sources":["../../src/schemas/paginatedResponse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,uBAAuB,GAAI,CAAC,SAAS,CAAC,CAAC,aAAa,cAAc,CAAC;;;aAI5E,CAAA;AAEJ,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI;IACjC,KAAK,EAAE,CAAC,EAAE,CAAA;IACV,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAC1B,CAAA"}

package/dist/schemas/paginatedResponse.js

@@ -0,0 +1,5 @@
+import * as v from 'valibot';
+export const paginatedResponseSchema = (itemSchema) => v.object({
+    items: v.array(itemSchema),
+    nextCursor: v.nullable(v.string()),
+});

package/dist/schemas/pushNotifications.d.ts

@@ -1,11 +1,11 @@
-import { v } from '../utils/valibot/index.js';
+import * as v from 'valibot';
 export declare const pushNotifications: {
-    payload: v.ObjectSchema<{
+    payload: v.UnionSchema<[v.ObjectSchema<{
         readonly data: v.ObjectSchema<{
             readonly messageId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>, v.BrandAction<string, "MessageId">]>, 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>;
         }, undefined>;
         readonly event: v.LiteralSchema<"EMAIL_RECEIVED", undefined>;
-    }, undefined>;
+    }, undefined>], undefined>;
 };
 //# sourceMappingURL=pushNotifications.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pushNotifications.d.ts","sourceRoot":"","sources":["../../src/schemas/pushNotifications.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,6BAA6B,CAAA;AAY/C,eAAO,MAAM,iBAAiB;IAC5B,OAAO;;;;;;;CACR,CAAA"}
+{"version":3,"file":"pushNotifications.d.ts","sourceRoot":"","sources":["../../src/schemas/pushNotifications.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAc5B,eAAO,MAAM,iBAAiB;;;;;;;;CAE7B,CAAA"}

package/dist/schemas/pushNotifications.js

@@ -1,5 +1,5 @@
-import { v } from '../utils/valibot/index.js';
-import { id } from './id.js';
+import * as v from 'valibot';
+import { id } from './id';
 const pushNotificationEmailReceivedPayload = v.object({
     data: v.object({
         messageId: id.messageId.required(),
@@ -7,6 +7,7 @@ const pushNotificationEmailReceivedPayload = v.object({
     }),
     event: v.literal('EMAIL_RECEIVED'),
 });
+const pushNotificationPayload = v.union([pushNotificationEmailReceivedPayload]);
 export const pushNotifications = {
-    payload: pushNotificationEmailReceivedPayload,
+    payload: pushNotificationPayload,
 };

package/dist/schemas/string.d.ts

@@ -1,8 +1,10 @@
-import { v } from '../utils/valibot/index.js';
+import * as v from 'valibot';
 export declare const string: {
     email: () => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, undefined>;
-    mailboxAddress: () => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RfcEmailAction<string, undefined>]>, v.MaxLengthAction<string, 320, undefined>]>, undefined>;
+    enum: (values: Record<string, string>) => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EnumSchema<Record<string, string>, undefined>]>, undefined>;
+    matches: (regex: RegExp) => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>]>, undefined>;
     nullable: (maxLength?: number) => v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
+    optional: (maxLength?: number) => v.UndefinedableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
     required: (maxLength?: number) => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
 };
 //# sourceMappingURL=string.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/schemas/string.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,6BAA6B,CAAA;AAI/C,eAAO,MAAM,MAAM;IACjB,KAAK;IACL,cAAc;IACd,QAAQ;IACR,QAAQ;CACT,CAAA"}
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/schemas/string.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,MAAM;;mBAEF,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;qBACpB,MAAM;;;;CAIxB,CAAA"}

package/dist/schemas/string.js

@@ -1,8 +1,9 @@
-import { v } from '../utils/valibot/index.js';
-import { mailboxAddressSchema, rfcEmailSchema } from './scalars.js';
+import * as v from 'valibot';
 export const string = {
-    email: () => v.nonOptional(rfcEmailSchema),
-    mailboxAddress: () => v.nonOptional(mailboxAddressSchema),
+    email: () => v.nonOptional(v.pipe(v.string(), v.rfcEmail())),
+    enum: (values) => v.nonOptional(v.pipe(v.string(), v.enum(values))),
+    matches: (regex) => v.nonOptional(v.pipe(v.string(), v.regex(regex))),
     nullable: (maxLength = 255) => v.nullable(v.pipe(v.string(), v.nonEmpty(), v.maxLength(maxLength))),
+    optional: (maxLength = 255) => v.undefinedable(v.pipe(v.string(), v.nonEmpty(), v.maxLength(maxLength))),
     required: (maxLength = 255) => v.nonOptional(v.pipe(v.string(), v.nonEmpty(), v.maxLength(maxLength))),
 };

package/dist/schemas/websocket.d.ts

@@ -0,0 +1,14 @@
+import * as v from 'valibot';
+export declare const pokeEventSchema: v.LooseObjectSchema<{
+    readonly event: v.LiteralSchema<"poke", undefined>;
+    readonly ids: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly model: v.PicklistSchema<readonly ["user", "account", "contact", "draft", "thread"], undefined>;
+}, undefined>;
+export declare const websocket: {
+    pokeEvent: v.LooseObjectSchema<{
+        readonly event: v.LiteralSchema<"poke", undefined>;
+        readonly ids: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly model: v.PicklistSchema<readonly ["user", "account", "contact", "draft", "thread"], undefined>;
+    }, undefined>;
+};
+//# sourceMappingURL=websocket.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../src/schemas/websocket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B,eAAO,MAAM,eAAe;;;;aAI1B,CAAA;AAEF,eAAO,MAAM,SAAS;;;;;;CAErB,CAAA"}

package/dist/schemas/websocket.js

@@ -0,0 +1,10 @@
+import * as v from 'valibot';
+import { POKE_MODELS } from '../types';
+export const pokeEventSchema = v.looseObject({
+    event: v.literal('poke'),
+    ids: v.optional(v.array(v.string())),
+    model: v.picklist(POKE_MODELS),
+});
+export const websocket = {
+    pokeEvent: pokeEventSchema,
+};

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

@@ -0,0 +1,12 @@
+import type { GenericSchema } from 'valibot';
+import type { BodyType, EndpointConfig, HTTPMethod, SDKResponse, URLPattern } from '../../types/Endpoint';
+export declare const createURLPattern: <T extends string>(pattern: T) => (params: URLPattern<T>) => string;
+export declare const createEndpoint: <TPath extends string, TRequestBody extends GenericSchema | undefined, TRequestQuery extends GenericSchema | undefined, TResponse extends GenericSchema<SDKResponse>>(params: {
+    body?: TRequestBody;
+    bodyType?: BodyType;
+    method: HTTPMethod;
+    path: TPath;
+    query?: TRequestQuery;
+    response: TResponse;
+}) => EndpointConfig<TPath, TRequestBody, TRequestQuery, TResponse>;
+//# sourceMappingURL=createEndpointConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createEndpointConfig.d.ts","sourceRoot":"","sources":["../../../src/sdk/endpoints/createEndpointConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE5C,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AAEjH,eAAO,MAAM,gBAAgB,GAC1B,CAAC,SAAS,MAAM,WAAW,CAAC,cACpB,UAAU,CAAC,CAAC,CAAC,KAAG,MAWxB,CAAA;AAEH,eAAO,MAAM,cAAc,GACzB,KAAK,SAAS,MAAM,EACpB,YAAY,SAAS,aAAa,GAAG,SAAS,EAC9C,aAAa,SAAS,aAAa,GAAG,SAAS,EAC/C,SAAS,SAAS,aAAa,CAAC,WAAW,CAAC,UACpC;IACR,IAAI,CAAC,EAAE,YAAY,CAAA;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,MAAM,EAAE,UAAU,CAAA;IAClB,IAAI,EAAE,KAAK,CAAA;IACX,KAAK,CAAC,EAAE,aAAa,CAAA;IACrB,QAAQ,EAAE,SAAS,CAAA;CACpB,KAAG,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,CAQ9D,CAAA"}

package/dist/sdk/endpoints/createEndpointConfig.js

@@ -0,0 +1,21 @@
+export const createURLPattern = (pattern) => (params) => {
+    const segments = pattern.split('/');
+    return segments
+        .map(segment => {
+        if (segment.startsWith(':')) {
+            const paramName = segment.slice(1);
+            return params[paramName];
+        }
+        return segment;
+    })
+        .join('/');
+};
+export const createEndpoint = (params) => ({
+    body: params.body,
+    bodyType: params.bodyType ?? 'json',
+    buildPath: createURLPattern(params.path),
+    method: params.method,
+    path: params.path,
+    query: params.query,
+    response: params.response,
+});

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

@@ -0,0 +1,255 @@
+import type { GenericSchema } from 'valibot';
+import type { EndpointConfig } from '../../types';
+export declare const endpoints: {
+    private: {
+        draftAttachment: {
+            upload: EndpointConfig<"/v1/pv/drafts/:attachmentId/upload", import("valibot").BlobSchema<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 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 status: import("valibot").LiteralSchema<200, undefined>;
+            }, undefined>], undefined>>;
+        };
+        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>>;
+        };
+        models: {
+            account: typeof import("./private/models/account");
+            contact: typeof import("./private/models/contact");
+            draft: typeof import("./private/models/draft");
+            thread: typeof import("./private/models/thread");
+            user: typeof import("./private/models/user");
+        };
+        mutations: {
+            account: typeof import("./private/mutations/account");
+            draft: typeof import("./private/mutations/draft");
+            thread: typeof import("./private/mutations/thread");
+            user: typeof import("./private/mutations/user");
+        };
+        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>>;
+            uploadProfilePicture: EndpointConfig<"/v1/pv/user/profile-picture", import("valibot").BlobSchema<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<"FILE_TOO_LARGE", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<413, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"INVALID_FILE_TYPE", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<415, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly code: import("valibot").LiteralSchema<"INVALID_IMAGE_DIMENSIONS", undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<415, undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly data: import("valibot").ObjectSchema<{
+                    readonly profilePicture: import("valibot").StringSchema<undefined>;
+                }, undefined>;
+                readonly status: import("valibot").LiteralSchema<200, 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").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>>;
+            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").RfcEmailAction<string, 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").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>, 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").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>>;
+        };
+        config: EndpointConfig<"/v1/pb/config", GenericSchema | undefined, GenericSchema | undefined, import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly app: import("valibot").ObjectSchema<{
+                    readonly minimumVersion: 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>>;
+        healthcheck: EndpointConfig<"/v1/pb/healthcheck", GenericSchema | undefined, GenericSchema | undefined, import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly status: import("valibot").LiteralSchema<"ok", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<200, undefined>;
+        }, undefined>>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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;AAWtE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGM,CAAA"}

package/dist/sdk/endpoints/index.js

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

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

@@ -0,0 +1,31 @@
+export declare const draftAttachment: {
+    upload: import("../../../..").EndpointConfig<"/v1/pv/drafts/:attachmentId/upload", import("valibot").BlobSchema<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 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 status: import("valibot").LiteralSchema<200, undefined>;
+    }, undefined>], undefined>>;
+};
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,4 @@
+import { uploadDraftAttachment } from './uploadDraftAttachment';
+export const draftAttachment = {
+    upload: uploadDraftAttachment,
+};

package/dist/sdk/endpoints/private/draftAttachment/uploadDraftAttachment.d.ts

@@ -0,0 +1,30 @@
+import * as v from 'valibot';
+export declare const uploadDraftAttachment: import("../../../..").EndpointConfig<"/v1/pv/drafts/:attachmentId/upload", v.BlobSchema<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 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 status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=uploadDraftAttachment.d.ts.map

package/dist/sdk/endpoints/private/draftAttachment/uploadDraftAttachment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadDraftAttachment.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/draftAttachment/uploadDraftAttachment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAU5B,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAchC,CAAA"}

package/dist/sdk/endpoints/private/draftAttachment/uploadDraftAttachment.js

@@ -0,0 +1,18 @@
+import * as v from 'valibot';
+import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
+import { attachmentNotFoundErrorSchema, attachmentStateInvalidErrorSchema, authFailedErrorSchema, validationFailedErrorSchema, } from '../../../../sdk/validation/errors';
+export const uploadDraftAttachment = createEndpoint({
+    body: v.blob(),
+    bodyType: 'blob',
+    method: 'POST',
+    path: '/v1/pv/drafts/:attachmentId/upload',
+    response: v.union([
+        authFailedErrorSchema,
+        attachmentNotFoundErrorSchema,
+        attachmentStateInvalidErrorSchema,
+        validationFailedErrorSchema,
+        v.object({
+            status: v.literal(200),
+        }),
+    ]),
+});

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