@marcoappio/marco-config 5.0.1 → 6.0.1

package/dist/sdk/index.d.ts

@@ -66,59 +66,6 @@ export declare const marcoSDK: {
                 user: typeof import("./endpoints/private/mutations/user");
             };
             user: {
-                createBillingPortalSession: import("..").EndpointConfig<"/v1/pv/user/create-billing-portal-session", import("valibot").ObjectSchema<{
-                    readonly returnUrl: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
-                }, undefined>, import("valibot").GenericSchema | undefined, import("valibot").UnionSchema<[import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"AUTHENTICATION_FAILED", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<401, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
-                        readonly issues: import("valibot").ObjectSchema<{
-                            readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
-                            readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-                            readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-                        }, undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<400, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"SUBSCRIPTION_NOT_FOUND", undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<404, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly url: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<200, undefined>;
-                }, undefined>], undefined>>;
-                createCheckoutSession: 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 data: import("valibot").ObjectSchema<{
-                        readonly code: import("valibot").LiteralSchema<"VALIDATION_FAILED", undefined>;
-                        readonly issues: import("valibot").ObjectSchema<{
-                            readonly nested: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>, undefined>, undefined>;
-                            readonly other: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-                            readonly root: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
-                        }, undefined>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<400, undefined>;
-                }, undefined>, import("valibot").ObjectSchema<{
-                    readonly data: import("valibot").ObjectSchema<{
-                        readonly url: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").UrlAction<string, undefined>]>;
-                    }, undefined>;
-                    readonly status: import("valibot").LiteralSchema<200, undefined>;
-                }, undefined>], undefined>>;
                 deleteUser: 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>;
@@ -432,12 +379,6 @@ export declare const marcoSDK: {
                 }, undefined>;
                 readonly status: import("valibot").LiteralSchema<409, undefined>;
             }, undefined>;
-            readonly subscriptionNotFoundErrorSchema: import("valibot").ObjectSchema<{
-                readonly data: import("valibot").ObjectSchema<{
-                    readonly code: import("valibot").LiteralSchema<"SUBSCRIPTION_NOT_FOUND", undefined>;
-                }, undefined>;
-                readonly status: import("valibot").LiteralSchema<404, undefined>;
-            }, undefined>;
             readonly threadNotFoundErrorSchema: import("valibot").ObjectSchema<{
                 readonly data: import("valibot").ObjectSchema<{
                     readonly code: import("valibot").LiteralSchema<"THREAD_NOT_FOUND", 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/sdk/validation/errors.d.ts

@@ -131,12 +131,6 @@ export declare const viewNotFoundErrorSchema: v.ObjectSchema<{
     }, undefined>;
     readonly status: v.LiteralSchema<404, undefined>;
 }, undefined>;
-export declare const subscriptionNotFoundErrorSchema: v.ObjectSchema<{
-    readonly data: v.ObjectSchema<{
-        readonly code: v.LiteralSchema<"SUBSCRIPTION_NOT_FOUND", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<404, undefined>;
-}, undefined>;
 export declare const validationFailedErrorSchema: v.ObjectSchema<{
     readonly data: v.ObjectSchema<{
         readonly code: v.LiteralSchema<"VALIDATION_FAILED", undefined>;
@@ -293,12 +287,6 @@ export declare const errors: {
         }, undefined>;
         readonly status: v.LiteralSchema<409, undefined>;
     }, undefined>;
-    readonly subscriptionNotFoundErrorSchema: v.ObjectSchema<{
-        readonly data: v.ObjectSchema<{
-            readonly code: v.LiteralSchema<"SUBSCRIPTION_NOT_FOUND", undefined>;
-        }, undefined>;
-        readonly status: v.LiteralSchema<404, undefined>;
-    }, undefined>;
     readonly threadNotFoundErrorSchema: v.ObjectSchema<{
         readonly data: v.ObjectSchema<{
             readonly code: v.LiteralSchema<"THREAD_NOT_FOUND", undefined>;

package/dist/sdk/validation/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/sdk/validation/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,yBAAyB;;;;;aAGpC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;aAGzC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,uCAAuC;;;;;aAGlD,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;aAGhC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;aAG3C,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;aAGxC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;aAGtC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;aAGpC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;aAGxC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;;aAG1C,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;aAUtC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BT,CAAA"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/sdk/validation/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,yBAAyB;;;;;aAGpC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;aAGzC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,uCAAuC;;;;;aAGlD,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;aAGhC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;aAG3C,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;aAGxC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;aAGtC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;aAGpC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;aAGxC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;aAUtC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;aAGlC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;aAGrC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;aAG5C,CAAA;AAEF,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BT,CAAA"}

package/dist/sdk/validation/errors.js

@@ -87,10 +87,6 @@ export const viewNotFoundErrorSchema = v.object({
     data: v.object({ code: v.literal('VIEW_NOT_FOUND') }),
     status: v.literal(404),
 });
-export const subscriptionNotFoundErrorSchema = v.object({
-    data: v.object({ code: v.literal('SUBSCRIPTION_NOT_FOUND') }),
-    status: v.literal(404),
-});
 export const validationFailedErrorSchema = v.object({
     data: v.object({
         code: v.literal('VALIDATION_FAILED'),
@@ -136,7 +132,6 @@ export const errors = {
     labelNotFoundErrorSchema,
     messageNotFoundErrorSchema,
     mutationRejectedErrorSchema,
-    subscriptionNotFoundErrorSchema,
     threadNotFoundErrorSchema,
     userMarkedForDeletionErrorSchema,
     userNotFoundErrorSchema,

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

@@ -126,12 +126,6 @@ export declare const validation: {
             }, undefined>;
             readonly status: import("valibot").LiteralSchema<409, undefined>;
         }, undefined>;
-        readonly subscriptionNotFoundErrorSchema: import("valibot").ObjectSchema<{
-            readonly data: import("valibot").ObjectSchema<{
-                readonly code: import("valibot").LiteralSchema<"SUBSCRIPTION_NOT_FOUND", undefined>;
-            }, undefined>;
-            readonly status: import("valibot").LiteralSchema<404, undefined>;
-        }, undefined>;
         readonly threadNotFoundErrorSchema: import("valibot").ObjectSchema<{
             readonly data: import("valibot").ObjectSchema<{
                 readonly code: import("valibot").LiteralSchema<"THREAD_NOT_FOUND", undefined>;

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

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

package/dist/types/SDKError.d.ts

@@ -1,4 +1,4 @@
 import type * as v from 'valibot';
 import type { errors } from '../sdk/validation/errors';
-export type SDKError = v.InferOutput<typeof errors.accountNotFoundErrorSchema> | v.InferOutput<typeof errors.aliasNotFoundErrorSchema> | v.InferOutput<typeof errors.attachmentNotFoundErrorSchema> | v.InferOutput<typeof errors.attachmentStateInvalidErrorSchema> | v.InferOutput<typeof errors.authCodeExpiredErrorSchema> | v.InferOutput<typeof errors.authCodeInvalidErrorSchema> | v.InferOutput<typeof errors.authCodePreviouslyUsedErrorSchema> | v.InferOutput<typeof errors.authFailedErrorSchema> | v.InferOutput<typeof errors.authRefreshTokenInvalid> | v.InferOutput<typeof errors.authServerResponseUnexpectedErrorSchema> | v.InferOutput<typeof errors.authTooManyAttemptsErrorSchema> | v.InferOutput<typeof errors.contactNotFoundErrorSchema> | v.InferOutput<typeof errors.draftNotFoundErrorSchema> | v.InferOutput<typeof errors.fileTooLargeErrorSchema> | v.InferOutput<typeof errors.invalidFileTypeErrorSchema> | v.InferOutput<typeof errors.invalidImageDimensionsErrorSchema> | v.InferOutput<typeof errors.inviteNotFoundErrorSchema> | v.InferOutput<typeof errors.labelAlreadyExistsErrorSchema> | v.InferOutput<typeof errors.labelNotFoundErrorSchema> | v.InferOutput<typeof errors.messageNotFoundErrorSchema> | v.InferOutput<typeof errors.mutationRejectedErrorSchema> | v.InferOutput<typeof errors.threadNotFoundErrorSchema> | v.InferOutput<typeof errors.userMarkedForDeletionErrorSchema> | v.InferOutput<typeof errors.userNotFoundErrorSchema> | v.InferOutput<typeof errors.validationFailedErrorSchema> | v.InferOutput<typeof errors.viewNotFoundErrorSchema> | v.InferOutput<typeof errors.subscriptionNotFoundErrorSchema>;
+export type SDKError = v.InferOutput<typeof errors.accountNotFoundErrorSchema> | v.InferOutput<typeof errors.aliasNotFoundErrorSchema> | v.InferOutput<typeof errors.attachmentNotFoundErrorSchema> | v.InferOutput<typeof errors.attachmentStateInvalidErrorSchema> | v.InferOutput<typeof errors.authCodeExpiredErrorSchema> | v.InferOutput<typeof errors.authCodeInvalidErrorSchema> | v.InferOutput<typeof errors.authCodePreviouslyUsedErrorSchema> | v.InferOutput<typeof errors.authFailedErrorSchema> | v.InferOutput<typeof errors.authRefreshTokenInvalid> | v.InferOutput<typeof errors.authServerResponseUnexpectedErrorSchema> | v.InferOutput<typeof errors.authTooManyAttemptsErrorSchema> | v.InferOutput<typeof errors.contactNotFoundErrorSchema> | v.InferOutput<typeof errors.draftNotFoundErrorSchema> | v.InferOutput<typeof errors.fileTooLargeErrorSchema> | v.InferOutput<typeof errors.invalidFileTypeErrorSchema> | v.InferOutput<typeof errors.invalidImageDimensionsErrorSchema> | v.InferOutput<typeof errors.inviteNotFoundErrorSchema> | v.InferOutput<typeof errors.labelAlreadyExistsErrorSchema> | v.InferOutput<typeof errors.labelNotFoundErrorSchema> | v.InferOutput<typeof errors.messageNotFoundErrorSchema> | v.InferOutput<typeof errors.mutationRejectedErrorSchema> | v.InferOutput<typeof errors.threadNotFoundErrorSchema> | v.InferOutput<typeof errors.userMarkedForDeletionErrorSchema> | v.InferOutput<typeof errors.userNotFoundErrorSchema> | v.InferOutput<typeof errors.validationFailedErrorSchema> | v.InferOutput<typeof errors.viewNotFoundErrorSchema>;
 //# sourceMappingURL=SDKError.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"SDKError.d.ts","sourceRoot":"","sources":["../../src/types/SDKError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAA;AAEjE,MAAM,MAAM,QAAQ,GAChB,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,wBAAwB,CAAC,GACrD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,6BAA6B,CAAC,GAC1D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,qBAAqB,CAAC,GAClD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uCAAuC,CAAC,GACpE,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,8BAA8B,CAAC,GAC3D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,wBAAwB,CAAC,GACrD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,yBAAyB,CAAC,GACtD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,6BAA6B,CAAC,GAC1D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,wBAAwB,CAAC,GACrD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,2BAA2B,CAAC,GACxD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,yBAAyB,CAAC,GACtD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,gCAAgC,CAAC,GAC7D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,2BAA2B,CAAC,GACxD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,+BAA+B,CAAC,CAAA"}
+{"version":3,"file":"SDKError.d.ts","sourceRoot":"","sources":["../../src/types/SDKError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAA;AAEjE,MAAM,MAAM,QAAQ,GAChB,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,wBAAwB,CAAC,GACrD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,6BAA6B,CAAC,GAC1D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,qBAAqB,CAAC,GAClD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uCAAuC,CAAC,GACpE,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,8BAA8B,CAAC,GAC3D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,wBAAwB,CAAC,GACrD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,iCAAiC,CAAC,GAC9D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,yBAAyB,CAAC,GACtD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,6BAA6B,CAAC,GAC1D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,wBAAwB,CAAC,GACrD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,0BAA0B,CAAC,GACvD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,2BAA2B,CAAC,GACxD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,yBAAyB,CAAC,GACtD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,gCAAgC,CAAC,GAC7D,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,GACpD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,2BAA2B,CAAC,GACxD,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,CAAC,uBAAuB,CAAC,CAAA"}

package/dist/types/index.d.ts

@@ -12,7 +12,5 @@ export * from './MessageRecipientType';
 export * from './OAuthProvider';
 export * from './PokeEvent';
 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,YAAY,CAAA;AAC1B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA;AAClC,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,gBAAgB,CAAA"}

package/dist/types/index.js

@@ -12,6 +12,4 @@ export * from './MessageRecipientType';
 export * from './OAuthProvider';
 export * from './PokeEvent';
 export * from './SDKError';
-export * from './StripeSubscriptionStatus';
-export * from './SubscriptionTier';
 export * from './UserSettings';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marcoappio/marco-config",
-  "version": "5.0.1",
+  "version": "6.0.1",
   "author": "team@marcoapp.io",
   "main": "dist/index.js",
   "repository": "git@github.com:marcoappio/marco-config.git",
@@ -10,6 +10,7 @@
   },
   "files": [
     "dist/",
+    "!dist/**/*.test.*",
     ".eslintrc.json"
   ],
   "auto": {
@@ -27,7 +28,6 @@
   "dependencies": {
     "@orama/stemmers": "3.1.16",
     "@orama/stopwords": "3.1.16",
-    "stripe": "20.3.0",
     "type-fest": "5.4.2",
     "valibot": "1.1.0"
   },

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

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

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

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

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

@@ -1,39 +0,0 @@
-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/stripe.d.ts

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

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

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

package/dist/schemas/stripe.js

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

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

@@ -1,30 +0,0 @@
-import * as v from 'valibot';
-export declare const createBillingPortalSession: import("../../../..").EndpointConfig<"/v1/pv/user/create-billing-portal-session", v.ObjectSchema<{
-    readonly returnUrl: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, 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 code: v.LiteralSchema<"SUBSCRIPTION_NOT_FOUND", undefined>;
-    }, undefined>;
-    readonly status: v.LiteralSchema<404, 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=createBillingPortalSession.d.ts.map

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

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

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

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

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

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

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

@@ -1,20 +0,0 @@
-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/types/StripeSubscriptionStatus.d.ts

@@ -1,3 +0,0 @@
-export declare const STRIPE_SUBSCRIPTION_STATUSES: readonly ["active", "canceled", "incomplete", "incomplete_expired", "past_due", "paused", "trialing", "unpaid"];
-export type StripeSubscriptionStatus = (typeof STRIPE_SUBSCRIPTION_STATUSES)[number];
-//# sourceMappingURL=StripeSubscriptionStatus.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"StripeSubscriptionStatus.d.ts","sourceRoot":"","sources":["../../src/types/StripeSubscriptionStatus.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,4BAA4B,iHASiB,CAAA;AAE1D,MAAM,MAAM,wBAAwB,GAAG,CAAC,OAAO,4BAA4B,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/types/StripeSubscriptionStatus.js

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

package/dist/types/SubscriptionTier.d.ts

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

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

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

package/dist/utils/threads/parseLabelIdList/parseLabelIdList.test.d.ts

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

package/dist/utils/threads/parseLabelIdList/parseLabelIdList.test.d.ts.map

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

package/dist/utils/threads/parseLabelIdList/parseLabelIdList.test.js

@@ -1,18 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { parseLabelIdList } from './index';
-describe('parseLabelIdList', () => {
-    const testCases = [
-        { description: 'parses space-separated IDs', expected: ['id1', 'id2', 'id3'], input: ' id1 id2 id3 ' },
-        { description: 'handles single ID', expected: ['id1'], input: ' id1 ' },
-        { description: 'handles empty string', expected: [], input: '' },
-        { description: 'handles whitespace only', expected: [], input: '   ' },
-        { description: 'handles no padding', expected: ['id1', 'id2'], input: 'id1 id2' },
-        { description: 'handles extra internal spaces', expected: ['id1', 'id2'], input: 'id1  id2' },
-        { description: 'handles UUID-style IDs', expected: ['abc-123', 'def-456'], input: ' abc-123 def-456 ' },
-    ];
-    for (const { input, expected, description } of testCases) {
-        it(`should ${description}`, () => {
-            expect(parseLabelIdList(input)).toEqual(expected);
-        });
-    }
-});

package/dist/utils/threads/processSearchTerm/processSearchTerm.test.d.ts

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

package/dist/utils/threads/processSearchTerm/processSearchTerm.test.d.ts.map

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

package/dist/utils/threads/processSearchTerm/processSearchTerm.test.js

@@ -1,38 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { processSearchTerm } from './processSearchTerm';
-describe('processSearchTerm', () => {
-    const testCases = [
-        { description: 'stems word to root form', expected: ['run'], input: 'running' },
-        { description: 'stems -ing suffix', expected: ['jump'], input: 'jumping' },
-        { description: 'stems plural', expected: ['cat'], input: 'cats' },
-        { description: 'removes single stopword', expected: [], input: 'the' },
-        { description: 'removes article stopword', expected: [], input: 'an' },
-        { description: 'removes verb stopword', expected: [], input: 'is' },
-        { description: 'removes stopwords from phrase', expected: ['quick', 'fox'], input: 'the quick fox' },
-        { description: 'handles empty string', expected: [], input: '' },
-        { description: 'handles whitespace only', expected: [], input: '   ' },
-        { description: 'handles tabs and newlines', expected: [], input: '\t\n' },
-        { description: 'returns empty for only stopwords', expected: [], input: 'the an' },
-        { description: 'returns empty for multiple stopwords', expected: [], input: 'is are was were' },
-        { description: 'deduplicates same-root words', expected: ['run'], input: 'run running runs' },
-        { description: 'deduplicates stemmed variants', expected: ['happi'], input: 'happy happiness' },
-        { description: 'normalizes uppercase', expected: ['hello'], input: 'HELLO' },
-        { description: 'normalizes mixed case', expected: ['hello', 'world'], input: 'HeLLo WoRLd' },
-        { description: 'handles extra spaces', expected: ['hello', 'world'], input: '  hello   world  ' },
-        { description: 'handles mixed whitespace', expected: ['hello', 'world'], input: 'hello\t\nworld' },
-        { description: 'preserves order of first occurrence', expected: ['world', 'hello'], input: 'world hello' },
-        {
-            description: 'handles mixed stopwords and content',
-            expected: ['meet', 'import'],
-            input: 'the meeting is important',
-        },
-        { description: 'stems and filters mixed phrase', expected: ['import', 'messag'], input: 'an important message' },
-        { description: 'passes through numbers unchanged', expected: ['123', 'test'], input: '123 test' },
-        { description: 'passes through special characters unchanged', expected: ['@user', '#tag'], input: '@user #tag' },
-    ];
-    for (const { input, expected, description } of testCases) {
-        it(`should ${description}`, () => {
-            expect(processSearchTerm(input)).toEqual(expected);
-        });
-    }
-});