@marcoappio/marco-config 4.0.25 → 5.0.1

package/dist/schemas/mutators/mutatorSchemas.js

@@ -0,0 +1,229 @@
+import * as v from 'valibot';
+import { marcoConstants } from '../../constants';
+import { DRAFT_ATTACHMENT_UPLOAD_STATUSES, DRAFT_STATUSES, DRAFT_TYPES, USER_SETTINGS_CUSTOM_VIEW_ICONS, } from '../../types';
+import { emailAccount } from '../emailAccount';
+import { id } from '../id';
+import { number } from '../number';
+import { string } from '../string';
+const accountAliasSchema = v.object({
+    emailAddress: string.email(),
+    id: id.aliasId.required(),
+    name: string.nullable(),
+});
+const accountsSchema = v.record(string.required(), v.object({
+    threadIds: v.array(id.threadId.required()),
+}));
+const baseThreadSchema = v.object({
+    accounts: accountsSchema,
+});
+const threadChangeLabelSchema = v.object({
+    accounts: accountsSchema,
+    labelPath: string.required(),
+});
+const draftBodySchema = v.object({
+    bcc: v.array(string.email()),
+    cc: v.array(string.email()),
+    content: v.pipe(v.string(), v.maxLength(384000)),
+    subject: string.nullable(),
+    to: v.array(string.email()),
+});
+const draftAttachmentSchema = v.object({
+    fileName: string.required(),
+    id: id.attachmentId.required(),
+    mimeType: string.required(),
+    status: v.picklist(DRAFT_ATTACHMENT_UPLOAD_STATUSES),
+    totalSize: number.positiveInteger(),
+});
+const userPushNotificationTokenSchema = v.object({
+    createdAt: number.positiveInteger(),
+    id: id.pushNotificationTokenId.required(),
+    token: string.required(),
+});
+const userViewSchema = v.object({
+    aliasEmails: v.pipe(v.array(string.email()), v.minLength(2), v.maxLength(marcoConstants.user.views.maxAliasEmailsPerView)),
+    icon: v.picklist(USER_SETTINGS_CUSTOM_VIEW_ICONS),
+    id: id.viewId.required(),
+    name: string.required(),
+});
+export const mutatorSchemas = {
+    account: {
+        createAccount: v.object({
+            aliasId: id.aliasId.required(),
+            color: string.required(),
+            emailAddress: string.email(),
+            id: id.accountId.required(),
+        }),
+        createAlias: v.object({
+            accountId: id.accountId.required(),
+            alias: accountAliasSchema,
+        }),
+        createLabel: v.object({
+            accountId: id.accountId.required(),
+            labelId: id.labelId.required(),
+            name: v.pipe(v.string(), v.nonEmpty(), v.maxLength(255)),
+        }),
+        deleteAccount: v.object({
+            id: id.accountId.required(),
+        }),
+        deleteAlias: v.object({
+            accountId: id.accountId.required(),
+            aliasId: id.aliasId.required(),
+        }),
+        deleteLabel: v.object({
+            accountId: id.accountId.required(),
+            labelId: id.labelId.required(),
+        }),
+        renameLabel: v.object({
+            accountId: id.accountId.required(),
+            labelId: id.labelId.required(),
+            name: v.pipe(v.string(), v.nonEmpty(), v.maxLength(255)),
+        }),
+        setAliasName: v.object({
+            accountId: id.accountId.required(),
+            aliasId: id.aliasId.required(),
+            displayName: string.nullable(),
+        }),
+        setAliasPrimary: v.object({
+            accountId: id.accountId.required(),
+            aliasId: id.aliasId.required(),
+        }),
+        setAliasSignature: v.object({
+            accountId: id.accountId.required(),
+            aliasId: id.aliasId.required(),
+            signature: v.nullable(v.pipe(v.string(), v.maxLength(50000))),
+        }),
+        setConnectionConfigImapRaw: v.object({
+            connectionConfig: emailAccount.connectionConfigImapRaw(),
+            id: id.accountId.required(),
+        }),
+        setConnectionConfigOauth: v.object({
+            connectionConfig: emailAccount.connectionConfigOauth(),
+            id: id.accountId.required(),
+        }),
+        setSettings: v.object({
+            color: v.optional(string.nullable()),
+            displayName: v.optional(string.nullable()),
+            id: id.accountId.required(),
+        }),
+    },
+    draft: {
+        cancelSend: v.object({
+            id: id.draftId.required(),
+            updatedAt: number.positiveInteger(),
+        }),
+        createAttachment: v.object({
+            attachment: draftAttachmentSchema,
+            id: id.draftId.required(),
+            updatedAt: number.positiveInteger(),
+        }),
+        createDraft: v.object({
+            accountId: id.accountId.required(),
+            attachments: v.array(draftAttachmentSchema),
+            body: draftBodySchema,
+            error: string.nullable(),
+            from: string.email(),
+            fromName: string.nullable(),
+            id: id.draftId.required(),
+            referencedMessageId: id.messageId.nullable(),
+            scheduledFor: v.nullable(number.positiveInteger()),
+            status: v.picklist(DRAFT_STATUSES),
+            type: v.picklist(DRAFT_TYPES),
+            updatedAt: number.positiveInteger(),
+        }),
+        deleteAttachment: v.object({
+            attachmentId: id.attachmentId.required(),
+            id: id.draftId.required(),
+            updatedAt: number.positiveInteger(),
+        }),
+        deleteDraft: v.object({
+            id: id.draftId.required(),
+        }),
+        replaceContent: v.object({
+            content: v.pipe(v.string(), v.maxLength(384000)),
+            id: id.draftId.required(),
+            updatedAt: number.positiveInteger(),
+        }),
+        scheduleSend: v.union([
+            v.object({
+                id: id.draftId.required(),
+                kind: v.literal('IMMEDIATE'),
+                undoMs: number.positiveInteger(),
+                updatedAt: number.positiveInteger(),
+            }),
+            v.object({
+                id: id.draftId.required(),
+                kind: v.literal('SCHEDULED'),
+                scheduledFor: number.positiveInteger(),
+                updatedAt: number.positiveInteger(),
+            }),
+        ]),
+        setEnvelope: v.object({
+            envelope: v.omit(draftBodySchema, ['content']),
+            id: id.draftId.required(),
+            updatedAt: number.positiveInteger(),
+        }),
+        setFrom: v.object({
+            accountId: id.accountId.required(),
+            aliasId: id.aliasId.required(),
+            from: string.email(),
+            fromName: string.nullable(),
+            id: id.draftId.required(),
+            updatedAt: number.positiveInteger(),
+        }),
+    },
+    thread: {
+        addLabel: threadChangeLabelSchema,
+        delete: baseThreadSchema,
+        removeLabel: threadChangeLabelSchema,
+        setArchive: baseThreadSchema,
+        setFlagged: v.object({
+            accounts: accountsSchema,
+            flagged: v.boolean(),
+        }),
+        setInbox: baseThreadSchema,
+        setSeen: v.object({
+            accounts: accountsSchema,
+            seen: v.boolean(),
+        }),
+        setSnooze: v.object({
+            accounts: accountsSchema,
+            snoozedUntil: v.nullable(number.positiveInteger()),
+        }),
+        setSpam: baseThreadSchema,
+        setTrash: baseThreadSchema,
+    },
+    user: {
+        createFeedback: v.object({
+            feedbackText: v.optional(v.pipe(v.string(), v.nonEmpty(), v.maxLength(4000))),
+            id: id.userId.required(),
+            rating: v.nonOptional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(5))),
+        }),
+        createView: v.object({
+            id: id.userId.required(),
+            view: userViewSchema,
+        }),
+        deleteSettingsPushNotificationToken: v.object({
+            id: id.userId.required(),
+            token: string.required(),
+        }),
+        deleteView: v.object({
+            id: id.userId.required(),
+            viewId: id.viewId.required(),
+        }),
+        setFeedbackModalShown: v.object({
+            id: id.userId.required(),
+        }),
+        setSettingsName: v.object({
+            id: id.userId.required(),
+            name: string.nullable(),
+        }),
+        setSettingsPushNotificationToken: v.object({
+            id: id.userId.required(),
+            pushNotificationToken: userPushNotificationTokenSchema,
+        }),
+        updateView: v.object({
+            id: id.userId.required(),
+            view: userViewSchema,
+        }),
+    },
+};

package/dist/schemas/mutators/mutatorSchemas.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mutatorSchemas.test.d.ts.map

package/dist/schemas/mutators/mutatorSchemas.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutatorSchemas.test.d.ts","sourceRoot":"","sources":["../../../src/schemas/mutators/mutatorSchemas.test.ts"],"names":[],"mappings":""}

package/dist/schemas/mutators/mutatorSchemas.test.js

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'bun:test';
+import * as v from 'valibot';
+import { mutatorSchemas } from './mutatorSchemas';
+describe('mutatorSchemas.user.createFeedback', () => {
+    const testCases = [
+        {
+            description: 'omitted feedbackText',
+            input: {
+                id: 'user_01K4FZ8D9QCA8ZA9DCE3W1SET3',
+                rating: 5,
+            },
+            success: true,
+        },
+        {
+            description: 'non-empty feedbackText',
+            input: {
+                feedbackText: 'test-feedback-text',
+                id: 'user_01K4FZ8D9QCA8ZA9DCE3W1SET3',
+                rating: 5,
+            },
+            success: true,
+        },
+        {
+            description: 'empty feedbackText',
+            input: {
+                feedbackText: '',
+                id: 'user_01K4FZ8D9QCA8ZA9DCE3W1SET3',
+                rating: 5,
+            },
+            success: false,
+        },
+    ];
+    for (const testCase of testCases) {
+        it(`handles ${testCase.description}`, () => {
+            const result = v.safeParse(mutatorSchemas.user.createFeedback, testCase.input);
+            expect(result.success).toBe(testCase.success);
+        });
+    }
+});

package/dist/schemas/number.d.ts

@@ -1,7 +1,9 @@
-import { v } from '../utils/valibot/index.js';
+import * as v from 'valibot';
 export declare const number: {
+    fromString: () => v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.TransformAction<string, number>, v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>;
     minMax: (min: number, max: number) => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
-    nonNegativeInteger: () => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
-    positiveInteger: () => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>;
+    nullable: () => v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    positiveInteger: () => v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    positiveIntegerFromString: () => v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.TransformAction<string, number>, v.NumberSchema<undefined>, v.FiniteAction<number, undefined>]>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
 };
 //# sourceMappingURL=number.d.ts.map

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/stripe.d.ts

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

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

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

@@ -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,
+});