@m5kdev/backend 0.1.0 → 0.1.1

package/dist/src/types.d.ts

@@ -0,0 +1,486 @@
+import type { Mastra } from "@mastra/core";
+import type { AIService } from "#modules/ai/ai.service";
+import type { AuthService } from "#modules/auth/auth.service";
+import type { BillingService } from "#modules/billing/billing.service";
+export declare const createAuthTRPCRouter: <MastraInstance extends Mastra>(authService: AuthService, aiService: AIService<MastraInstance>, billingService: BillingService) => import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        session: {
+            id: string;
+            userId: string;
+            expiresAt: Date;
+            createdAt: Date;
+            updatedAt: Date;
+            token: string;
+            ipAddress: string | null;
+            userAgent: string | null;
+            impersonatedBy: string | null;
+            activeOrganizationId: string | null;
+            activeOrganizationRole: string | null;
+            activeTeamId: string | null;
+            activeTeamRole: string | null;
+        };
+        user: {
+            name: string;
+            image: string | null;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            metadata: Record<string, unknown>;
+            emailVerified: boolean;
+            role: string | null;
+            banned: boolean | null;
+            banReason: string | null;
+            banExpires: Date | null;
+            stripeCustomerId: string | null;
+            paymentCustomerId: string | null;
+            paymentPlanTier: string | null;
+            paymentPlanExpiresAt: Date | null;
+            preferences: string | null;
+            onboarding: number | null;
+            flags: string | null;
+        };
+    };
+    meta: import("trpc-to-openapi").OpenApiMeta;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    auth: import("@trpc/server").TRPCBuiltRouter<{
+        ctx: {
+            session: {
+                id: string;
+                userId: string;
+                expiresAt: Date;
+                createdAt: Date;
+                updatedAt: Date;
+                token: string;
+                ipAddress: string | null;
+                userAgent: string | null;
+                impersonatedBy: string | null;
+                activeOrganizationId: string | null;
+                activeOrganizationRole: string | null;
+                activeTeamId: string | null;
+                activeTeamRole: string | null;
+            };
+            user: {
+                name: string;
+                image: string | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                metadata: Record<string, unknown>;
+                emailVerified: boolean;
+                role: string | null;
+                banned: boolean | null;
+                banReason: string | null;
+                banExpires: Date | null;
+                stripeCustomerId: string | null;
+                paymentCustomerId: string | null;
+                paymentPlanTier: string | null;
+                paymentPlanExpiresAt: Date | null;
+                preferences: string | null;
+                onboarding: number | null;
+                flags: string | null;
+            };
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: true;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        getUserWaitlistCount: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: number;
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        createInvitationCode: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                name?: string | undefined;
+            };
+            output: {
+                id: string;
+                name: string | null;
+                email: string | null;
+                createdAt: Date;
+                updatedAt: Date | null;
+                status: string;
+                code: string | null;
+                expiresAt: Date | null;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        createAccountClaimCode: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                userId: string;
+                expiresInHours?: number | undefined;
+            };
+            output: {
+                id: string;
+                claimUserId: string | null;
+                code: string | null;
+                status: string;
+                expiresAt: Date | null;
+                claimedAt: Date | null;
+                claimedEmail: string | null;
+                createdAt: Date;
+                updatedAt: Date | null;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        listAccountClaims: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: {
+                id: string;
+                expiresAt: Date | null;
+                createdAt: Date;
+                updatedAt: Date | null;
+                status: string;
+                claimUserId: string | null;
+                claimedAt: Date | null;
+                claimedEmail: string | null;
+            }[];
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        generateAccountClaimMagicLink: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                claimId: string;
+                email?: string | undefined;
+            };
+            output: {
+                id: string;
+                userId: string;
+                expiresAt: Date | null;
+                createdAt: Date;
+                email: string;
+                url: string;
+                claimId: string;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        listAccountClaimMagicLinks: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                claimId: string;
+            };
+            output: {
+                id: string;
+                userId: string;
+                expiresAt: Date | null;
+                createdAt: Date;
+                email: string;
+                url: string;
+                claimId: string;
+            }[];
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        getMyAccountClaimStatus: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: {
+                id: string;
+                claimUserId: string | null;
+                code: string | null;
+                status: string;
+                expiresAt: Date | null;
+                claimedAt: Date | null;
+                claimedEmail: string | null;
+                createdAt: Date;
+                updatedAt: Date | null;
+            } | null;
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        setMyAccountClaimEmail: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                email: string;
+            };
+            output: {
+                status: boolean;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        acceptMyAccountClaim: import("@trpc/server").TRPCMutationProcedure<{
+            input: void;
+            output: {
+                status: boolean;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        listWaitlist: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: {
+                id: string;
+                name: string | null;
+                email: string | null;
+                createdAt: Date;
+                updatedAt: Date | null;
+                status: string;
+                code: string | null;
+                expiresAt: Date | null;
+            }[];
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        listAdminWaitlist: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: {
+                name: string | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date | null;
+                email: string | null;
+                status: string;
+            }[];
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        addToWaitlist: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                email: string;
+            };
+            output: {
+                name: string | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date | null;
+                email: string | null;
+                status: string;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        inviteToWaitlist: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                email: string;
+                name?: string | undefined;
+            };
+            output: {
+                id: string;
+                name: string | null;
+                email: string | null;
+                createdAt: Date;
+                updatedAt: Date | null;
+                status: string;
+                code: string | null;
+                expiresAt: Date | null;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        inviteFromWaitlist: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                name: string | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date | null;
+                email: string | null;
+                status: string;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        removeFromWaitlist: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                id: string;
+            };
+            output: {
+                name: string | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date | null;
+                email: string | null;
+                status: string;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        joinWaitlist: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                email: string;
+            };
+            output: {
+                name: string | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date | null;
+                email: string | null;
+                status: string;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        getOnboarding: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: number;
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        setOnboarding: import("@trpc/server").TRPCMutationProcedure<{
+            input: number;
+            output: number;
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        getPreferences: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: Record<string, unknown>;
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        setPreferences: import("@trpc/server").TRPCMutationProcedure<{
+            input: Record<string, unknown>;
+            output: Record<string, unknown>;
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        getMetadata: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: Record<string, unknown>;
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        setMetadata: import("@trpc/server").TRPCMutationProcedure<{
+            input: Record<string, unknown>;
+            output: Record<string, unknown>;
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        getFlags: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: string[];
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        setFlags: import("@trpc/server").TRPCMutationProcedure<{
+            input: string[];
+            output: string[];
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        validateWaitlistCode: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                code: string;
+            };
+            output: {
+                status: string;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+    }>>;
+    ai: import("@trpc/server").TRPCBuiltRouter<{
+        ctx: {
+            session: {
+                id: string;
+                userId: string;
+                expiresAt: Date;
+                createdAt: Date;
+                updatedAt: Date;
+                token: string;
+                ipAddress: string | null;
+                userAgent: string | null;
+                impersonatedBy: string | null;
+                activeOrganizationId: string | null;
+                activeOrganizationRole: string | null;
+                activeTeamId: string | null;
+                activeTeamRole: string | null;
+            };
+            user: {
+                name: string;
+                image: string | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                metadata: Record<string, unknown>;
+                emailVerified: boolean;
+                role: string | null;
+                banned: boolean | null;
+                banReason: string | null;
+                banExpires: Date | null;
+                stripeCustomerId: string | null;
+                paymentCustomerId: string | null;
+                paymentPlanTier: string | null;
+                paymentPlanExpiresAt: Date | null;
+                preferences: string | null;
+                onboarding: number | null;
+                flags: string | null;
+            };
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: true;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        getUserUsage: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                userId: string;
+            };
+            output: {
+                inputTokens: number | null;
+                outputTokens: number | null;
+                totalTokens: number | null;
+                cost: number | null;
+            };
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+    }>>;
+    billing: import("@trpc/server").TRPCBuiltRouter<{
+        ctx: {
+            session: {
+                id: string;
+                userId: string;
+                expiresAt: Date;
+                createdAt: Date;
+                updatedAt: Date;
+                token: string;
+                ipAddress: string | null;
+                userAgent: string | null;
+                impersonatedBy: string | null;
+                activeOrganizationId: string | null;
+                activeOrganizationRole: string | null;
+                activeTeamId: string | null;
+                activeTeamRole: string | null;
+            };
+            user: {
+                name: string;
+                image: string | null;
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                metadata: Record<string, unknown>;
+                emailVerified: boolean;
+                role: string | null;
+                banned: boolean | null;
+                banReason: string | null;
+                banExpires: Date | null;
+                stripeCustomerId: string | null;
+                paymentCustomerId: string | null;
+                paymentPlanTier: string | null;
+                paymentPlanExpiresAt: Date | null;
+                preferences: string | null;
+                onboarding: number | null;
+                flags: string | null;
+            };
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: true;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        getActiveSubscription: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: {
+                id: string;
+                plan: string;
+                referenceId: string;
+                status: string;
+                stripeCustomerId?: string | null | undefined;
+                stripeSubscriptionId?: string | null | undefined;
+                periodStart?: Date | null | undefined;
+                periodEnd?: Date | null | undefined;
+                cancelAtPeriodEnd?: boolean | null | undefined;
+                cancelAt?: Date | null | undefined;
+                canceledAt?: Date | null | undefined;
+                seats?: number | null | undefined;
+                trialStart?: Date | null | undefined;
+                trialEnd?: Date | null | undefined;
+                priceId?: string | null | undefined;
+                interval?: string | null | undefined;
+                unitAmount?: number | null | undefined;
+                discounts?: string[] | null | undefined;
+            } | null;
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+        listInvoices: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: import("stripe").Stripe.Invoice[];
+            meta: import("trpc-to-openapi").OpenApiMeta;
+        }>;
+    }>>;
+}>>;
+export type BackendTRPCRouter = ReturnType<typeof createAuthTRPCRouter>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAExD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,oBAAoB,GAAI,cAAc,SAAS,MAAM,EAChE,aAAa,WAAW,EACxB,WAAW,SAAS,CAAC,cAAc,CAAC,EACpC,gBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAM5B,CAAC;AAEL,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/src/utils/errors.d.ts

@@ -0,0 +1,50 @@
+import type { captureException } from "@sentry/node";
+import { type TRPC_ERROR_CODE_KEY, TRPCError } from "@trpc/server";
+import type { ServerErrorLayer } from "#modules/base/base.types";
+export type { ServerErrorLayer };
+export declare class ServerError extends Error {
+    readonly code: TRPC_ERROR_CODE_KEY;
+    readonly layer: ServerErrorLayer;
+    readonly layerName: string;
+    readonly clientMessage?: string;
+    readonly context?: Record<string, unknown>;
+    readonly boundaryStack?: string;
+    constructor({ code, layer, layerName, message, clientMessage, cause, context, captureBoundary, }: {
+        code: TRPC_ERROR_CODE_KEY;
+        layer?: ServerErrorLayer;
+        layerName?: string;
+        message?: string;
+        clientMessage?: string;
+        cause?: unknown;
+        context?: Record<string, unknown>;
+        captureBoundary?: boolean;
+    });
+    is5xxError(): boolean;
+    getHTTPStatusCode(): number;
+    toTRPC(): TRPCError;
+    toJSON(): {
+        code: "PARSE_ERROR" | "BAD_REQUEST" | "INTERNAL_SERVER_ERROR" | "NOT_IMPLEMENTED" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "GATEWAY_TIMEOUT" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_SUPPORTED" | "TIMEOUT" | "CONFLICT" | "PRECONDITION_FAILED" | "PAYLOAD_TOO_LARGE" | "UNSUPPORTED_MEDIA_TYPE" | "UNPROCESSABLE_CONTENT" | "TOO_MANY_REQUESTS" | "CLIENT_CLOSED_REQUEST";
+        layer: ServerErrorLayer;
+        layerName: string;
+        message: string;
+        context: Record<string, unknown> | undefined;
+        stack: string | undefined;
+        boundaryStack: string | undefined;
+        cause: unknown;
+    };
+    static fromUnknown(code: TRPC_ERROR_CODE_KEY, cause: unknown, opts?: {
+        layer?: ServerErrorLayer;
+        layerName?: string;
+        context?: Record<string, unknown>;
+    }): ServerError;
+}
+export type ErrorReporter = {
+    captureException: (err: Parameters<typeof captureException>[0], hint?: Parameters<typeof captureException>[1]) => string;
+};
+declare global {
+    var m5ErrorReporter: ErrorReporter | undefined;
+}
+export declare function getErrorReporter(): ErrorReporter | undefined;
+export declare function setErrorReporter(reporter: ErrorReporter): void;
+export declare function reportError(err: ServerError | Error | unknown, hint?: Parameters<typeof captureException>[1]): string | undefined;
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/utils/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/utils/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,KAAK,mBAAmB,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGjE,YAAY,EAAE,gBAAgB,EAAE,CAAC;AACjC,qBAAa,WAAY,SAAQ,KAAK;IACpC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;gBAEpB,EACV,IAAI,EACJ,KAAK,EACL,SAAS,EACT,OAAO,EACP,aAAa,EACb,KAAK,EACL,OAAO,EACP,eAAsB,GACvB,EAAE;QACD,IAAI,EAAE,mBAAmB,CAAC;QAC1B,KAAK,CAAC,EAAE,gBAAgB,CAAC;QACzB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAClC,eAAe,CAAC,EAAE,OAAO,CAAC;KAC3B;IAiBD,UAAU,IAAI,OAAO;IAKrB,iBAAiB,IAAI,MAAM;IAI3B,MAAM,IAAI,SAAS;IAQnB,MAAM;;;;;;;;;;IAiBN,MAAM,CAAC,WAAW,CAChB,IAAI,EAAE,mBAAmB,EACzB,KAAK,EAAE,OAAO,EACd,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,gBAAgB,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE;CAa7F;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,gBAAgB,EAAE,CAChB,GAAG,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC,EAC3C,IAAI,CAAC,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC,KAC1C,MAAM,CAAC;CACb,CAAC;AACF,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,eAAe,EAAE,aAAa,GAAG,SAAS,CAAC;CAChD;AAED,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,SAAS,CAE5D;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,QAEvD;AAED,wBAAgB,WAAW,CACzB,GAAG,EAAE,WAAW,GAAG,KAAK,GAAG,OAAO,EAClC,IAAI,CAAC,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC,GAC5C,MAAM,GAAG,SAAS,CAsBpB"}

package/dist/src/utils/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const logger: import("pino").Logger<never, boolean>;
+//# sourceMappingURL=logger.d.ts.map

package/dist/src/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/utils/logger.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,uCAKjB,CAAC"}

package/dist/src/utils/posthog.d.ts

@@ -0,0 +1,14 @@
+import type { PostHog } from "posthog-node";
+declare global {
+    var m5Posthog: PostHog | undefined;
+}
+export declare function getPosthog(): PostHog | undefined;
+export declare function setPosthog(posthog: PostHog): void;
+type PosthogRequestState = {
+    disableCapture: boolean;
+};
+export declare function runWithPosthogRequestState<T>(state: PosthogRequestState, callback: () => T): T;
+export declare function isPosthogCaptureDisabled(): boolean;
+export declare function posthogCapture(event: Parameters<PostHog["capture"]>[0]): ReturnType<PostHog["capture"]> | undefined;
+export {};
+//# sourceMappingURL=posthog.d.ts.map

package/dist/src/utils/posthog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"posthog.d.ts","sourceRoot":"","sources":["../../../src/utils/posthog.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,SAAS,EAAE,OAAO,GAAG,SAAS,CAAC;CACpC;AAED,wBAAgB,UAAU,IAAI,OAAO,GAAG,SAAS,CAEhD;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,QAE1C;AAED,KAAK,mBAAmB,GAAG;IACzB,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAIF,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,KAAK,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAE9F;AAED,wBAAgB,wBAAwB,IAAI,OAAO,CAElD;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GACvC,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAU5C"}

package/dist/src/utils/types.d.ts

@@ -0,0 +1,5 @@
+import type { Result } from "neverthrow";
+import type { ServerError } from "./errors";
+export type ServerResult<T> = Result<T, ServerError>;
+export type ServerResultAsync<T> = Promise<ServerResult<T>>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;AACrD,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC"}