@marcoappio/marco-config 2.0.552 → 2.0.554

package/dist/marcoPublicConfig.d.ts

@@ -1,3 +1,4 @@
+import type { SubscriptionTier } from './types';
 export type MarcoEnvironment = 'production' | 'staging' | 'development';
 export declare const MARCO_ENV: MarcoEnvironment;
 type MarcoPublicConfig = {
@@ -27,6 +28,17 @@ type MarcoPublicConfig = {
             tenantId: string;
         };
     };
+    stripe: {
+        products: {
+            [key in SubscriptionTier]: {
+                id: string;
+                priceIds: {
+                    monthly: string;
+                    yearly: string;
+                };
+            };
+        };
+    };
     workOS: {
         clientId: string;
     };

package/dist/marcoPublicConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"marcoPublicConfig.d.ts","sourceRoot":"","sources":["../src/marcoPublicConfig.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAAG,SAAS,GAAG,aAAa,CAAA;AAEvE,eAAO,MAAM,SAAS,kBAGP,CAAA;AAEf,KAAK,iBAAiB,GAAG;IACvB,KAAK,EAAE;QACL,GAAG,EAAE;YACH,OAAO,EAAE,MAAM,CAAA;SAChB,CAAA;QACD,GAAG,EAAE;YACH,OAAO,EAAE,MAAM,CAAA;SAChB,CAAA;QACD,GAAG,EAAE;YACH,OAAO,EAAE,MAAM,CAAA;YACf,UAAU,EAAE,MAAM,CAAA;SACnB,CAAA;QACD,EAAE,EAAE;YACF,KAAK,EAAE,MAAM,CAAA;YACb,IAAI,EAAE,MAAM,CAAA;YACZ,GAAG,EAAE,MAAM,CAAA;SACZ,CAAA;KACF,CAAA;IACD,KAAK,EAAE;QACL,MAAM,EAAE;YACN,QAAQ,EAAE,MAAM,CAAA;SACjB,CAAA;QACD,OAAO,EAAE;YACP,QAAQ,EAAE,MAAM,CAAA;YAChB,QAAQ,EAAE,MAAM,CAAA;SACjB,CAAA;KACF,CAAA;IACD,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,CAAA;KACjB,CAAA;CACF,CAAA;AAkGD,eAAO,MAAM,iBAAiB,SAAS,gBAAgB,sBAAmC,CAAA"}
+{"version":3,"file":"marcoPublicConfig.d.ts","sourceRoot":"","sources":["../src/marcoPublicConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAE/C,MAAM,MAAM,gBAAgB,GAAG,YAAY,GAAG,SAAS,GAAG,aAAa,CAAA;AAEvE,eAAO,MAAM,SAAS,kBAGP,CAAA;AAEf,KAAK,iBAAiB,GAAG;IACvB,KAAK,EAAE;QACL,GAAG,EAAE;YACH,OAAO,EAAE,MAAM,CAAA;SAChB,CAAA;QACD,GAAG,EAAE;YACH,OAAO,EAAE,MAAM,CAAA;SAChB,CAAA;QACD,GAAG,EAAE;YACH,OAAO,EAAE,MAAM,CAAA;YACf,UAAU,EAAE,MAAM,CAAA;SACnB,CAAA;QACD,EAAE,EAAE;YACF,KAAK,EAAE,MAAM,CAAA;YACb,IAAI,EAAE,MAAM,CAAA;YACZ,GAAG,EAAE,MAAM,CAAA;SACZ,CAAA;KACF,CAAA;IACD,KAAK,EAAE;QACL,MAAM,EAAE;YACN,QAAQ,EAAE,MAAM,CAAA;SACjB,CAAA;QACD,OAAO,EAAE;YACP,QAAQ,EAAE,MAAM,CAAA;YAChB,QAAQ,EAAE,MAAM,CAAA;SACjB,CAAA;KACF,CAAA;IACD,MAAM,EAAE;QACN,QAAQ,EAAE;aACP,GAAG,IAAI,gBAAgB,GAAG;gBACzB,EAAE,EAAE,MAAM,CAAA;gBACV,QAAQ,EAAE;oBACR,OAAO,EAAE,MAAM,CAAA;oBACf,MAAM,EAAE,MAAM,CAAA;iBACf,CAAA;aACF;SACF,CAAA;KACF,CAAA;IACD,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,CAAA;KACjB,CAAA;CACF,CAAA;AAmID,eAAO,MAAM,iBAAiB,SAAS,gBAAgB,sBAAmC,CAAA"}

package/dist/marcoPublicConfig.js

@@ -29,6 +29,17 @@ const configMap = {
                 tenantId: '33fe2afe-644d-4fe2-a264-c4f2c34fa2cf',
             },
         },
+        stripe: {
+            products: {
+                tier1: {
+                    id: 'prod_TJW6TuhbdtnvMq',
+                    priceIds: {
+                        monthly: 'price_1SMt4h1m1XCLGhl4Qm46GQ3t',
+                        yearly: 'price_1SMt5e1m1XCLGhl4nmyuoWqu',
+                    },
+                },
+            },
+        },
         workOS: {
             clientId: 'client_01J51ET6KV4GBGMGHY0PJ9VGP2',
         },
@@ -60,6 +71,17 @@ const configMap = {
                 tenantId: '33fe2afe-644d-4fe2-a264-c4f2c34fa2cf',
             },
         },
+        stripe: {
+            products: {
+                tier1: {
+                    id: 'prod_TJW8qBSheqSNKz',
+                    priceIds: {
+                        monthly: 'price_1SMt5vP4o4KWHCwtGb0oqK6q',
+                        yearly: 'price_1SMt5vP4o4KWHCwtS2DHx3eX',
+                    },
+                },
+            },
+        },
         workOS: {
             clientId: 'client_01J51ET6RT5WCS3NNQYBB7FAE7',
         },
@@ -91,6 +113,17 @@ const configMap = {
                 tenantId: '33fe2afe-644d-4fe2-a264-c4f2c34fa2cf',
             },
         },
+        stripe: {
+            products: {
+                tier1: {
+                    id: 'prod_TJW6TuhbdtnvMq',
+                    priceIds: {
+                        monthly: 'price_1SMt4h1m1XCLGhl4Qm46GQ3t',
+                        yearly: 'price_1SMt5e1m1XCLGhl4nmyuoWqu',
+                    },
+                },
+            },
+        },
         workOS: {
             clientId: 'client_01J51ET6KV4GBGMGHY0PJ9VGP2',
         },

package/dist/schemas/index.d.ts

@@ -1,3 +1,5 @@
+import { type StripeUserData } from './stripe';
+export type { StripeUserData };
 export type { Account, AccountAlias, AccountLabel, Contact, Draft, DraftAttachment, DraftBody, Thread, ThreadMessage, ThreadMessageAttachment, ThreadMessageRecipient, User, UserPushNotificationToken, UserView, } from './models';
 export { mutatorSchemas } from './mutators';
 export declare const marcoSchemas: {
@@ -137,6 +139,46 @@ export declare const marcoSchemas: {
             readonly updatedAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
             readonly userId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
         }, undefined>;
+        stripeUserDataSchema: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+            readonly customer: import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                readonly deleted: import("valibot").OptionalSchema<import("valibot").NeverSchema<undefined>, undefined>;
+                readonly email: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly id: import("valibot").StringSchema<undefined>;
+                readonly name: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly object: import("valibot").LiteralSchema<"customer", undefined>;
+            }, undefined>, import("valibot").ObjectSchema<{
+                readonly deleted: import("valibot").LiteralSchema<true, undefined>;
+                readonly id: import("valibot").StringSchema<undefined>;
+                readonly object: import("valibot").LiteralSchema<"customer", undefined>;
+            }, undefined>], undefined>;
+            readonly product: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                readonly description: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly id: import("valibot").StringSchema<undefined>;
+                readonly name: import("valibot").StringSchema<undefined>;
+                readonly object: import("valibot").LiteralSchema<"product", undefined>;
+            }, undefined>, undefined>;
+            readonly subscription: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                readonly cancelAtPeriodEnd: import("valibot").BooleanSchema<undefined>;
+                readonly discounts: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly coupon: import("valibot").ObjectSchema<{
+                        readonly amountOff: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                        readonly id: import("valibot").StringSchema<undefined>;
+                        readonly name: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                        readonly percentOff: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                    }, undefined>;
+                    readonly end: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                    readonly id: import("valibot").StringSchema<undefined>;
+                    readonly start: import("valibot").NumberSchema<undefined>;
+                }, undefined>, undefined>;
+                readonly id: import("valibot").StringSchema<undefined>;
+                readonly object: import("valibot").LiteralSchema<"subscription", undefined>;
+                readonly startDate: import("valibot").NumberSchema<undefined>;
+                readonly status: import("valibot").PicklistSchema<[import("stripe").Stripe.Subscription.Status, ...import("stripe").Stripe.Subscription.Status[]], undefined>;
+                readonly trialEnd: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                readonly trialStart: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+            readonly subscriptionTier: import("valibot").NullableSchema<import("valibot").PicklistSchema<readonly ["tier1"], undefined>, undefined>;
+        }, undefined>, undefined>;
         threadFullSchema: import("valibot").ObjectSchema<{
             readonly messages: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                 readonly accountId: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -261,8 +303,6 @@ export declare const marcoSchemas: {
         userSchema: import("valibot").ObjectSchema<{
             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 name: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly polarCustomerId: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-            readonly polarSubscriptionStatus: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").PicklistSchema<[import("@polar-sh/sdk/models/components/subscriptionstatus.js").SubscriptionStatus, ...import("@polar-sh/sdk/models/components/subscriptionstatus.js").SubscriptionStatus[]], undefined>, undefined>, undefined>;
             readonly profilePicture: import("valibot").NullableSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly pushNotificationTokens: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                 readonly createdAt: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").IntegerAction<number, undefined>, import("valibot").MinValueAction<number, 0, undefined>]>, undefined>;
@@ -270,6 +310,46 @@ export declare const marcoSchemas: {
                 readonly token: import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>;
                 readonly userId: 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 stripe: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                readonly customer: import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                    readonly deleted: import("valibot").OptionalSchema<import("valibot").NeverSchema<undefined>, undefined>;
+                    readonly email: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly id: import("valibot").StringSchema<undefined>;
+                    readonly name: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly object: import("valibot").LiteralSchema<"customer", undefined>;
+                }, undefined>, import("valibot").ObjectSchema<{
+                    readonly deleted: import("valibot").LiteralSchema<true, undefined>;
+                    readonly id: import("valibot").StringSchema<undefined>;
+                    readonly object: import("valibot").LiteralSchema<"customer", undefined>;
+                }, undefined>], undefined>;
+                readonly product: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly description: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly id: import("valibot").StringSchema<undefined>;
+                    readonly name: import("valibot").StringSchema<undefined>;
+                    readonly object: import("valibot").LiteralSchema<"product", undefined>;
+                }, undefined>, undefined>;
+                readonly subscription: import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly cancelAtPeriodEnd: import("valibot").BooleanSchema<undefined>;
+                    readonly discounts: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly coupon: import("valibot").ObjectSchema<{
+                            readonly amountOff: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                            readonly id: import("valibot").StringSchema<undefined>;
+                            readonly name: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                            readonly percentOff: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                        }, undefined>;
+                        readonly end: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                        readonly id: import("valibot").StringSchema<undefined>;
+                        readonly start: import("valibot").NumberSchema<undefined>;
+                    }, undefined>, undefined>;
+                    readonly id: import("valibot").StringSchema<undefined>;
+                    readonly object: import("valibot").LiteralSchema<"subscription", undefined>;
+                    readonly startDate: import("valibot").NumberSchema<undefined>;
+                    readonly status: import("valibot").PicklistSchema<[import("stripe").Stripe.Subscription.Status, ...import("stripe").Stripe.Subscription.Status[]], undefined>;
+                    readonly trialEnd: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                    readonly trialStart: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly subscriptionTier: import("valibot").NullableSchema<import("valibot").PicklistSchema<readonly ["tier1"], undefined>, undefined>;
+            }, undefined>, undefined>, undefined>;
             readonly undoSendEnabled: import("valibot").BooleanSchema<undefined>;
             readonly views: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                 readonly aliasEmails: import("valibot").ArraySchema<import("valibot").NonOptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").NonEmptyAction<string, undefined>, import("valibot").MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AA8BA,YAAY,EACV,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,OAAO,EACP,KAAK,EACL,eAAe,EACf,SAAS,EACT,MAAM,EACN,aAAa,EACb,uBAAuB,EACvB,sBAAsB,EACtB,IAAI,EACJ,yBAAyB,EACzB,QAAQ,GACT,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAE3C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BxB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schemas/index.ts"],"names":[],"mappings":"AA4BA,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,UAAU,CAAA;AAGpE,YAAY,EAAE,cAAc,EAAE,CAAA;AAE9B,YAAY,EACV,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,OAAO,EACP,KAAK,EACL,eAAe,EACf,SAAS,EACT,MAAM,EACN,aAAa,EACb,uBAAuB,EACvB,sBAAsB,EACtB,IAAI,EACJ,yBAAyB,EACzB,QAAQ,GACT,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAE3C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BxB,CAAA"}

package/dist/schemas/index.js

@@ -9,6 +9,7 @@ import { number } from './number';
 import { oauth } from './oauth';
 import { pushNotifications } from './pushNotifications';
 import { string } from './string';
+import { stripeUserDataSchema } from './stripe';
 import { websocket } from './websocket';
 export { mutatorSchemas } from './mutators';
 export const marcoSchemas = {
@@ -25,6 +26,7 @@ export const marcoSchemas = {
         draftAttachmentSchema,
         draftBodySchema,
         draftSchema,
+        stripeUserDataSchema,
         threadFullSchema,
         threadListSchema,
         threadMessageAttachmentSchema,

package/dist/schemas/models/user.d.ts

@@ -14,8 +14,6 @@ export declare const userPushNotificationTokenSchema: v.ObjectSchema<{
 export declare const userSchema: v.ObjectSchema<{
     readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
     readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    readonly polarCustomerId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-    readonly polarSubscriptionStatus: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<[import("@polar-sh/sdk/models/components/subscriptionstatus.js").SubscriptionStatus, ...import("@polar-sh/sdk/models/components/subscriptionstatus.js").SubscriptionStatus[]], undefined>, undefined>, undefined>;
     readonly profilePicture: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
     readonly pushNotificationTokens: v.ArraySchema<v.ObjectSchema<{
         readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
@@ -23,6 +21,46 @@ export declare const userSchema: v.ObjectSchema<{
         readonly token: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
         readonly userId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
     }, undefined>, undefined>;
+    readonly stripe: v.OptionalSchema<v.NullableSchema<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<[import("stripe").Stripe.Subscription.Status, ...import("stripe").Stripe.Subscription.Status[]], 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>, undefined>, undefined>;
     readonly undoSendEnabled: v.BooleanSchema<undefined>;
     readonly views: v.ArraySchema<v.ObjectSchema<{
         readonly aliasEmails: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;

package/dist/schemas/models/user.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../src/schemas/models/user.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,cAAc;;;;;aAKzB,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;;aAK1C,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;aASrB,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,UAAU,CAAC,CAAA;AACnD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,cAAc,CAAC,CAAA;AAC3D,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,+BAA+B,CAAC,CAAA"}
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../src/schemas/models/user.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAO5B,eAAO,MAAM,cAAc;;;;;aAKzB,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;;aAK1C,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAQrB,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,UAAU,CAAC,CAAA;AACnD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,cAAc,CAAC,CAAA;AAC3D,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,+BAA+B,CAAC,CAAA"}

package/dist/schemas/models/user.js

@@ -1,7 +1,8 @@
 import * as v from 'valibot';
 import { number } from '../../schemas/number';
 import { string } from '../../schemas/string';
-import { POLAR_SUBSCRIPTION_STATUSES, USER_SETTINGS_CUSTOM_VIEW_ICONS } from '../../types';
+import { stripeUserDataSchema } from '../../schemas/stripe';
+import { USER_SETTINGS_CUSTOM_VIEW_ICONS } from '../../types';
 export const userViewSchema = v.object({
     aliasEmails: v.array(string.required()),
     icon: v.picklist(USER_SETTINGS_CUSTOM_VIEW_ICONS),
@@ -17,10 +18,9 @@ export const userPushNotificationTokenSchema = v.object({
 export const userSchema = v.object({
     id: string.required(),
     name: string.nullable(),
-    polarCustomerId: v.optional(v.nullable(v.string())),
-    polarSubscriptionStatus: v.optional(v.nullable(v.picklist(POLAR_SUBSCRIPTION_STATUSES))),
     profilePicture: string.nullable(),
     pushNotificationTokens: v.array(userPushNotificationTokenSchema),
+    stripe: v.optional(stripeUserDataSchema),
     undoSendEnabled: v.boolean(),
     views: v.array(userViewSchema),
 });

package/dist/schemas/stripe.d.ts

@@ -0,0 +1,44 @@
+import type Stripe from 'stripe';
+import * as v from 'valibot';
+export declare const stripeUserDataSchema: v.NullableSchema<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<[Stripe.Subscription.Status, ...Stripe.Subscription.Status[]], 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>, 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":"AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAA;AAEhC,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAwE5B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAOhC,CAAA;AAED,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.nullable(v.object({
+    customer: v.union([stripeCustomerSchema, stripeDeletedCustomerSchema]),
+    product: v.nullable(stripeProductSchema),
+    subscription: v.nullable(stripeSubscriptionSchema),
+    subscriptionTier: v.nullable(v.picklist(SUBSCRIPTION_TIERS)),
+}));

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

@@ -67,25 +67,39 @@ export declare const endpoints: {
             user: typeof import("./private/mutations/user");
         };
         user: {
-            deleteUser: EndpointConfig<"/v1/pv/user", GenericSchema | undefined, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            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 status: import("valibot").LiteralSchema<204, undefined>;
-            }, undefined>], undefined>>;
-            getBillingPortalUrl: EndpointConfig<"/v1/pv/user/billing-portal-url", GenericSchema | undefined, GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                    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<401, 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>;

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

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

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

@@ -64,25 +64,39 @@ export declare const privateGroup: {
         user: typeof import("./mutations/user");
     };
     user: {
-        deleteUser: import("../../..").EndpointConfig<"/v1/pv/user", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+        createCheckoutSession: import("../../..").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>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
             readonly data: import("valibot").ObjectSchema<{
                 readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
             }, undefined>;
             readonly status: import("valibot").LiteralSchema<401, undefined>;
         }, undefined>, import("valibot").ObjectSchema<{
-            readonly status: import("valibot").LiteralSchema<204, undefined>;
-        }, undefined>], undefined>>;
-        getBillingPortalUrl: import("../../..").EndpointConfig<"/v1/pv/user/billing-portal-url", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
             readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                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<401, 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: import("../../..").EndpointConfig<"/v1/pv/user", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+            readonly data: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+            }, undefined>;
+            readonly status: import("valibot").LiteralSchema<401, undefined>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly status: import("valibot").LiteralSchema<204, undefined>;
+        }, undefined>], undefined>>;
         uploadProfilePicture: import("../../..").EndpointConfig<"/v1/pv/user/profile-picture", 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>;

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

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

package/dist/sdk/endpoints/private/models/user/getUser.d.ts

@@ -13,8 +13,6 @@ export declare const getUser: import("../../../../..").EndpointConfig<"/v1/pv/mo
     readonly data: v.ObjectSchema<{
         readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
         readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly polarCustomerId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
-        readonly polarSubscriptionStatus: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<[import("@polar-sh/sdk/models/components/subscriptionstatus.js").SubscriptionStatus, ...import("@polar-sh/sdk/models/components/subscriptionstatus.js").SubscriptionStatus[]], undefined>, undefined>, undefined>;
         readonly profilePicture: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
         readonly pushNotificationTokens: v.ArraySchema<v.ObjectSchema<{
             readonly createdAt: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
@@ -22,6 +20,46 @@ export declare const getUser: import("../../../../..").EndpointConfig<"/v1/pv/mo
             readonly token: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
             readonly userId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
         }, undefined>, undefined>;
+        readonly stripe: v.OptionalSchema<v.NullableSchema<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<[import("stripe").Stripe.Subscription.Status, ...import("stripe").Stripe.Subscription.Status[]], 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>, undefined>, undefined>;
         readonly undoSendEnabled: v.BooleanSchema<undefined>;
         readonly views: v.ArraySchema<v.ObjectSchema<{
             readonly aliasEmails: v.ArraySchema<v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;

package/dist/sdk/endpoints/private/models/user/getUser.d.ts.map

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

package/dist/sdk/endpoints/private/user/createCheckoutSession.d.ts

@@ -0,0 +1,27 @@
+import * as v from 'valibot';
+export declare const createCheckoutSession: import("../../../..").EndpointConfig<"/v1/pv/user/create-checkout-session", v.ObjectSchema<{
+    readonly cancelUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly priceId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly successUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+}, 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<"VALIDATION_FAILED", undefined>;
+        readonly issues: v.ObjectSchema<{
+            readonly nested: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
+            readonly other: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+            readonly root: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        }, undefined>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<400, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly data: v.ObjectSchema<{
+        readonly url: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
+    }, undefined>;
+    readonly status: v.LiteralSchema<200, undefined>;
+}, undefined>], undefined>>;
+//# sourceMappingURL=createCheckoutSession.d.ts.map

package/dist/sdk/endpoints/private/user/createCheckoutSession.d.ts.map

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

package/dist/sdk/endpoints/private/user/createCheckoutSession.js

@@ -0,0 +1,20 @@
+import * as v from 'valibot';
+import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
+import { authFailedErrorSchema, validationFailedErrorSchema } from '../../../../sdk/validation/errors';
+export const createCheckoutSession = createEndpoint({
+    body: v.object({
+        cancelUrl: v.pipe(v.string(), v.minLength(1)),
+        priceId: v.pipe(v.string(), v.minLength(1)),
+        successUrl: v.pipe(v.string(), v.minLength(1)),
+    }),
+    method: 'POST',
+    path: '/v1/pv/user/create-checkout-session',
+    response: v.union([
+        authFailedErrorSchema,
+        validationFailedErrorSchema,
+        v.object({
+            data: v.object({ url: v.pipe(v.string(), v.url()) }),
+            status: v.literal(200),
+        }),
+    ]),
+});

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

@@ -1,23 +1,37 @@
 export declare const user: {
-    deleteUser: import("../../../..").EndpointConfig<"/v1/pv/user", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+    createCheckoutSession: import("../../../..").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>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
         readonly data: import("valibot").ObjectSchema<{
             readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
         }, undefined>;
         readonly status: import("valibot").LiteralSchema<401, undefined>;
     }, undefined>, import("valibot").ObjectSchema<{
-        readonly status: import("valibot").LiteralSchema<204, undefined>;
-    }, undefined>], undefined>>;
-    getBillingPortalUrl: import("../../../..").EndpointConfig<"/v1/pv/user/billing-portal-url", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
         readonly data: import("valibot").ObjectSchema<{
-            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+            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<401, 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: import("../../../..").EndpointConfig<"/v1/pv/user", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+        readonly data: import("valibot").ObjectSchema<{
+            readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+        }, undefined>;
+        readonly status: import("valibot").LiteralSchema<401, undefined>;
+    }, undefined>, import("valibot").ObjectSchema<{
+        readonly status: import("valibot").LiteralSchema<204, undefined>;
+    }, undefined>], undefined>>;
     uploadProfilePicture: import("../../../..").EndpointConfig<"/v1/pv/user/profile-picture", 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>;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/user/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIhB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/endpoints/private/user/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIhB,CAAA"}

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

@@ -1,8 +1,8 @@
+import { createCheckoutSession } from './createCheckoutSession';
 import { deleteUser } from './deleteUser';
-import { getBillingPortalUrl } from './getBillingPortalUrl';
 import { uploadProfilePicture } from './uploadProfilePicture';
 export const user = {
+    createCheckoutSession,
     deleteUser,
-    getBillingPortalUrl,
     uploadProfilePicture,
 };

package/dist/sdk/index.d.ts

@@ -66,25 +66,39 @@ export declare const marcoSDK: {
                 user: typeof import("./endpoints/private/mutations/user");
             };
             user: {
-                deleteUser: import("..").EndpointConfig<"/v1/pv/user", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                createCheckoutSession: import("..").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>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
                     readonly data: import("valibot").ObjectSchema<{
                         readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
                     }, undefined>;
                     readonly status: import("valibot").LiteralSchema<401, undefined>;
                 }, undefined>, import("valibot").ObjectSchema<{
-                    readonly status: import("valibot").LiteralSchema<204, undefined>;
-                }, undefined>], undefined>>;
-                getBillingPortalUrl: import("..").EndpointConfig<"/v1/pv/user/billing-portal-url", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
                     readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                        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<401, 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: import("..").EndpointConfig<"/v1/pv/user", import("valibot").GenericSchema | undefined, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
+                    readonly data: import("valibot").ObjectSchema<{
+                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
+                    }, undefined>;
+                    readonly status: import("valibot").LiteralSchema<401, undefined>;
+                }, undefined>, import("valibot").ObjectSchema<{
+                    readonly status: import("valibot").LiteralSchema<204, undefined>;
+                }, undefined>], undefined>>;
                 uploadProfilePicture: import("..").EndpointConfig<"/v1/pv/user/profile-picture", 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>;

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

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

package/dist/types/StripeSubscriptionStatus.d.ts

@@ -0,0 +1,4 @@
+import type Stripe from 'stripe';
+export declare const STRIPE_SUBSCRIPTION_STATUSES: [Stripe.Subscription.Status, ...Stripe.Subscription.Status[]];
+export type StripeSubscriptionStatus = Stripe.Subscription.Status;
+//# sourceMappingURL=StripeSubscriptionStatus.d.ts.map

package/dist/types/StripeSubscriptionStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StripeSubscriptionStatus.d.ts","sourceRoot":"","sources":["../../src/types/StripeSubscriptionStatus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAA;AAahC,eAAO,MAAM,4BAA4B,EAAe,CAAC,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,GAAG,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAA;AAErH,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAAC,YAAY,CAAC,MAAM,CAAA"}

package/dist/types/StripeSubscriptionStatus.js

@@ -0,0 +1,11 @@
+const statuses = [
+    'active',
+    'canceled',
+    'incomplete',
+    'incomplete_expired',
+    'past_due',
+    'paused',
+    'trialing',
+    'unpaid',
+];
+export const STRIPE_SUBSCRIPTION_STATUSES = statuses;

package/dist/types/SubscriptionTier.d.ts

@@ -0,0 +1,3 @@
+export declare const SUBSCRIPTION_TIERS: readonly ["tier1"];
+export type SubscriptionTier = (typeof SUBSCRIPTION_TIERS)[number];
+//# sourceMappingURL=SubscriptionTier.d.ts.map

package/dist/types/SubscriptionTier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubscriptionTier.d.ts","sourceRoot":"","sources":["../../src/types/SubscriptionTier.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,oBAAqB,CAAA;AAEpD,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/types/SubscriptionTier.js

@@ -0,0 +1 @@
+export const SUBSCRIPTION_TIERS = ['tier1'];

package/dist/types/index.d.ts

@@ -11,7 +11,8 @@ export * from './MarcoPlatform';
 export * from './MessageRecipientType';
 export * from './OAuthProvider';
 export * from './PokeEvent';
-export * from './PolarSubscriptionStatus';
 export * from './SDKError';
+export * from './StripeSubscriptionStatus';
+export * from './SubscriptionTier';
 export * from './UserSettings';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,+BAA+B,CAAA;AAC7C,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,YAAY,CAAA;AAC1B,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,wBAAwB,CAAA;AACtC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,2BAA2B,CAAA;AACzC,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,+BAA+B,CAAA;AAC7C,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,YAAY,CAAA;AAC1B,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,wBAAwB,CAAA;AACtC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA"}

package/dist/types/index.js

@@ -11,6 +11,7 @@ export * from './MarcoPlatform';
 export * from './MessageRecipientType';
 export * from './OAuthProvider';
 export * from './PokeEvent';
-export * from './PolarSubscriptionStatus';
 export * from './SDKError';
+export * from './StripeSubscriptionStatus';
+export * from './SubscriptionTier';
 export * from './UserSettings';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marcoappio/marco-config",
-  "version": "2.0.552",
+  "version": "2.0.554",
   "author": "team@marcoapp.io",
   "main": "dist/index.js",
   "repository": "git@github.com:marcoappio/marco-config.git",
@@ -27,7 +27,8 @@
   "dependencies": {
     "@orama/stemmers": "3.1.16",
     "@orama/stopwords": "3.1.16",
-    "@polar-sh/sdk": "0.42.2",
+    "stripe": "20.3.0",
+    "type-fest": "5.4.2",
     "valibot": "1.1.0"
   },
   "devDependencies": {

package/dist/sdk/endpoints/private/user/getBillingPortalUrl.d.ts

@@ -1,13 +0,0 @@
-import * as v from 'valibot';
-export declare const getBillingPortalUrl: import("../../../..").EndpointConfig<"/v1/pv/user/billing-portal-url", 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 url: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<200, undefined>;
-}, undefined>], undefined>>;
-//# sourceMappingURL=getBillingPortalUrl.d.ts.map

package/dist/sdk/endpoints/private/user/getBillingPortalUrl.d.ts.map

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

package/dist/sdk/endpoints/private/user/getBillingPortalUrl.js

@@ -1,14 +0,0 @@
-import * as v from 'valibot';
-import { createEndpoint } from '../../../../sdk/endpoints/createEndpointConfig';
-import { authFailedErrorSchema } from '../../../../sdk/validation/errors';
-export const getBillingPortalUrl = createEndpoint({
-    method: 'GET',
-    path: '/v1/pv/user/billing-portal-url',
-    response: v.union([
-        authFailedErrorSchema,
-        v.object({
-            data: v.object({ url: v.pipe(v.string(), v.url()) }),
-            status: v.literal(200),
-        }),
-    ]),
-});

package/dist/types/PolarSubscriptionStatus.d.ts

@@ -1,4 +0,0 @@
-import { type SubscriptionStatus as PolarSubscriptionStatusType } from '@polar-sh/sdk/models/components/subscriptionstatus.js';
-export declare const POLAR_SUBSCRIPTION_STATUSES: [PolarSubscriptionStatusType, ...PolarSubscriptionStatusType[]];
-export type PolarSubscriptionStatus = PolarSubscriptionStatusType;
-//# sourceMappingURL=PolarSubscriptionStatus.d.ts.map

package/dist/types/PolarSubscriptionStatus.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PolarSubscriptionStatus.d.ts","sourceRoot":"","sources":["../../src/types/PolarSubscriptionStatus.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,IAAI,2BAA2B,EAEvD,MAAM,uDAAuD,CAAA;AAI9D,eAAO,MAAM,2BAA2B,EAAe,CAAC,2BAA2B,EAAE,GAAG,2BAA2B,EAAE,CAAC,CAAA;AAEtH,MAAM,MAAM,uBAAuB,GAAG,2BAA2B,CAAA"}

package/dist/types/PolarSubscriptionStatus.js

@@ -1,3 +0,0 @@
-import { SubscriptionStatus, } from '@polar-sh/sdk/models/components/subscriptionstatus.js';
-const statuses = Object.values(SubscriptionStatus);
-export const POLAR_SUBSCRIPTION_STATUSES = statuses;