@marcoappio/marco-config 2.0.599 → 3.0.1

package/dist/schemas/stripe.d.ts

@@ -1,43 +0,0 @@
-import * as v from 'valibot';
-export declare const stripeUserDataSchema: v.ObjectSchema<{
-    readonly customer: v.UnionSchema<[v.ObjectSchema<{
-        readonly deleted: v.OptionalSchema<v.NeverSchema<undefined>, undefined>;
-        readonly email: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        readonly id: v.StringSchema<undefined>;
-        readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        readonly object: v.LiteralSchema<"customer", undefined>;
-    }, undefined>, v.ObjectSchema<{
-        readonly deleted: v.LiteralSchema<true, undefined>;
-        readonly id: v.StringSchema<undefined>;
-        readonly object: v.LiteralSchema<"customer", undefined>;
-    }, undefined>], undefined>;
-    readonly product: v.NullableSchema<v.ObjectSchema<{
-        readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        readonly id: v.StringSchema<undefined>;
-        readonly name: v.StringSchema<undefined>;
-        readonly object: v.LiteralSchema<"product", undefined>;
-    }, undefined>, undefined>;
-    readonly subscription: v.NullableSchema<v.ObjectSchema<{
-        readonly cancelAtPeriodEnd: v.BooleanSchema<undefined>;
-        readonly discounts: v.ArraySchema<v.ObjectSchema<{
-            readonly coupon: v.ObjectSchema<{
-                readonly amountOff: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
-                readonly id: v.StringSchema<undefined>;
-                readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-                readonly percentOff: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
-            }, undefined>;
-            readonly end: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
-            readonly id: v.StringSchema<undefined>;
-            readonly start: v.NumberSchema<undefined>;
-        }, undefined>, undefined>;
-        readonly id: v.StringSchema<undefined>;
-        readonly object: v.LiteralSchema<"subscription", undefined>;
-        readonly startDate: v.NumberSchema<undefined>;
-        readonly status: v.PicklistSchema<readonly ["active", "canceled", "incomplete", "incomplete_expired", "past_due", "paused", "trialing", "unpaid"], undefined>;
-        readonly trialEnd: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
-        readonly trialStart: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
-    }, undefined>, undefined>;
-    readonly subscriptionTier: v.NullableSchema<v.PicklistSchema<readonly ["tier1"], undefined>, undefined>;
-}, undefined>;
-export type StripeUserData = v.InferOutput<typeof stripeUserDataSchema>;
-//# sourceMappingURL=stripe.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"stripe.d.ts","sourceRoot":"","sources":["../../src/schemas/stripe.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAwE5B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAK/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/schemas/stripe.js

@@ -1,48 +0,0 @@
-import * as v from 'valibot';
-import { STRIPE_SUBSCRIPTION_STATUSES, SUBSCRIPTION_TIERS } from '../types';
-const stripeCustomerSchema = v.object({
-    deleted: v.optional(v.never()),
-    email: v.nullable(v.string()),
-    id: v.string(),
-    name: v.nullable(v.string()),
-    object: v.literal('customer'),
-});
-const stripeDeletedCustomerSchema = v.object({
-    deleted: v.literal(true),
-    id: v.string(),
-    object: v.literal('customer'),
-});
-const stripeProductSchema = v.object({
-    description: v.nullable(v.string()),
-    id: v.string(),
-    name: v.string(),
-    object: v.literal('product'),
-});
-const stripeCouponSchema = v.object({
-    amountOff: v.nullable(v.number()),
-    id: v.string(),
-    name: v.nullable(v.string()),
-    percentOff: v.nullable(v.number()),
-});
-const stripeDiscountSchema = v.object({
-    coupon: stripeCouponSchema,
-    end: v.nullable(v.number()),
-    id: v.string(),
-    start: v.number(),
-});
-const stripeSubscriptionSchema = v.object({
-    cancelAtPeriodEnd: v.boolean(),
-    discounts: v.array(stripeDiscountSchema),
-    id: v.string(),
-    object: v.literal('subscription'),
-    startDate: v.number(),
-    status: v.picklist(STRIPE_SUBSCRIPTION_STATUSES),
-    trialEnd: v.nullable(v.number()),
-    trialStart: v.nullable(v.number()),
-});
-export const stripeUserDataSchema = v.object({
-    customer: v.union([stripeCustomerSchema, stripeDeletedCustomerSchema]),
-    product: v.nullable(stripeProductSchema),
-    subscription: v.nullable(stripeSubscriptionSchema),
-    subscriptionTier: v.nullable(v.picklist(SUBSCRIPTION_TIERS)),
-});

package/dist/schemas/websocket.d.ts

@@ -1,14 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,10 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,21 +0,0 @@
-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

@@ -1,308 +0,0 @@
-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: {
-            createBillingPortalSession: EndpointConfig<"/v1/pv/user/create-billing-portal-session", import("valibot").ObjectSchema<{
-                readonly returnUrl: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
-            }, 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<"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<"SUBSCRIPTION_NOT_FOUND", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<404, undefined>;
-            }, undefined>, import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly url: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<200, undefined>;
-            }, undefined>], undefined>>;
-            createCheckoutSession: EndpointConfig<"/v1/pv/user/create-checkout-session", import("valibot").ObjectSchema<{
-                readonly cancelUrl: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
-                readonly priceId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
-                readonly successUrl: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
-            }, 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<"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 url: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<200, undefined>;
-            }, undefined>], undefined>>;
-            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

@@ -1 +0,0 @@
-{"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,6 +0,0 @@
-import { privateGroup } from './private';
-import { publicGroup } from './public';
-export const endpoints = {
-    private: privateGroup,
-    public: publicGroup,
-};

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

@@ -1,31 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

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

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

@@ -1,30 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,18 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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