@windrun-huaiin/backend-core 10.0.1

package/dist/lib/stripe-config.mjs

@@ -0,0 +1,268 @@
+import { __awaiter } from '../node_modules/.pnpm/@rollup_plugin-typescript@12.1.4_rollup@4.46.2_tslib@2.8.1_typescript@5.9.3/node_modules/tslib/tslib.es6.mjs';
+import Stripe from 'stripe';
+import { userService } from '../services/database/user.service.mjs';
+import { subscriptionService } from '../services/database/subscription.service.mjs';
+import '../services/database/credit.service.mjs';
+import '@prisma/client';
+import '../prisma/prisma.mjs';
+import { Apilogger } from '../services/database/apilog.service.mjs';
+
+// Stripe Configuration
+const stripe = new Stripe(process.env.STRIPE_SECRET_KEY, {
+    apiVersion: '2025-10-29.clover',
+});
+// Helper function to validate webhook signature
+const validateStripeWebhook = (payload, signature, secret) => {
+    return stripe.webhooks.constructEvent(payload, signature, secret);
+};
+// Helper function to create checkout session
+const createCheckoutSession = (params, subscriptionData) => __awaiter(void 0, void 0, void 0, function* () {
+    const { priceId, customerId, clientReferenceId, successUrl, cancelUrl, metadata, interval } = params;
+    // ✅ Dynamic mode determination: subscription if interval is not 'onetime'
+    const mode = interval && interval !== 'onetime' ? 'subscription' : 'payment';
+    const isSubscriptionMode = mode === 'subscription';
+    if (isSubscriptionMode) {
+        if (!subscriptionData) {
+            throw new Error('Subscription data is required for subscription mode');
+        }
+        const activeSubscription = yield subscriptionService.getActiveSubscription(clientReferenceId);
+        if (activeSubscription) {
+            throw new ActiveSubscriptionExistsError();
+        }
+    }
+    const sessionParams = {
+        mode, // ✅ Dynamic mode
+        payment_method_types: ['card'],
+        line_items: [
+            {
+                price: priceId,
+                quantity: 1,
+            },
+        ],
+        success_url: successUrl,
+        cancel_url: cancelUrl,
+        client_reference_id: clientReferenceId,
+        metadata: Object.assign(Object.assign({}, metadata), { mode }),
+    };
+    // Add customer if provided
+    if (customerId) {
+        sessionParams.customer = customerId;
+    }
+    // One-time payment specific configuration
+    if (isSubscriptionMode) {
+        // 在这里注入订单元数据，以保证后续事件处理能根据订单去匹配处理，只能在订阅模式里设置数据，否则Stripe报错
+        sessionParams.subscription_data = subscriptionData;
+    }
+    else {
+        // One-time payments don't create invoices
+        sessionParams.invoice_creation = {
+            enabled: false,
+        };
+    }
+    // Create log record with request
+    const logId = yield Apilogger.logStripeOutgoing('createCheckoutSession', params);
+    try {
+        const session = yield stripe.checkout.sessions.create(sessionParams);
+        // Update log record with response
+        Apilogger.updateResponse(logId, {
+            session_id: session.id,
+            url: session.url,
+            mode: session.mode
+        });
+        return session;
+    }
+    catch (error) {
+        // Update log record with error
+        Apilogger.updateResponse(logId, {
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+        throw error;
+    }
+});
+// 根据发票ID去查支付ID
+const fetchPaymentId = (invoiceId) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const fullInvoice = yield stripe.invoices.retrieve(invoiceId, {
+        expand: ['payments']
+    });
+    const payment = (_a = fullInvoice.payments) === null || _a === void 0 ? void 0 : _a.data[0];
+    const paymentIntentInfo = (_b = payment === null || payment === void 0 ? void 0 : payment.payment) === null || _b === void 0 ? void 0 : _b.payment_intent;
+    const paymentIntentId = typeof paymentIntentInfo === 'string' ? paymentIntentInfo : paymentIntentInfo === null || paymentIntentInfo === void 0 ? void 0 : paymentIntentInfo.id;
+    return paymentIntentId;
+});
+// Helper function to create or retrieve customer
+const createOrGetCustomer = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const { userId } = params;
+    const user = yield userService.findByUserId(userId);
+    if (!user) {
+        throw new Error(`User not found for userId: ${userId}`);
+    }
+    const setStripeCustomerId = (stripeCusId) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield userService.updateStripeCustomerId(userId, stripeCusId);
+        }
+        catch (error) {
+            console.error('Failed to update stripe customer id', { userId, stripeCusId, error });
+        }
+    });
+    if (user.stripeCusId) {
+        try {
+            const customer = yield stripe.customers.retrieve(user.stripeCusId);
+            if ('deleted' in customer) {
+                yield setStripeCustomerId(null);
+            }
+            else {
+                return customer.id;
+            }
+        }
+        catch (error) {
+            yield setStripeCustomerId(null);
+            console.warn('Failed to retrieve Stripe customer, fallback to lookup by email', {
+                userId,
+                stripeCusId: user.stripeCusId,
+                error,
+            });
+        }
+    }
+    if (user.email) {
+        const existingCustomers = yield stripe.customers.list({
+            email: user.email,
+            limit: 1,
+        });
+        if (existingCustomers.data.length > 0) {
+            const stripeCustomer = existingCustomers.data[0];
+            if (!user.stripeCusId || user.stripeCusId !== stripeCustomer.id) {
+                yield setStripeCustomerId(stripeCustomer.id);
+            }
+            return stripeCustomer.id;
+        }
+    }
+    // 创建新客户
+    const customerParams = {
+        metadata: {
+            user_id: userId,
+        },
+    };
+    if (user.email) {
+        customerParams.email = user.email;
+    }
+    const derivedName = user.email ? user.email.split('@')[0] : undefined;
+    if (derivedName) {
+        customerParams.name = derivedName;
+    }
+    // Create log record with request
+    const logId = yield Apilogger.logStripeOutgoing('createCustomer', {
+        userId,
+        email: customerParams.email,
+        name: customerParams.name,
+    });
+    try {
+        const customer = yield stripe.customers.create(customerParams);
+        yield setStripeCustomerId(customer.id);
+        // Update log record with response
+        Apilogger.updateResponse(logId, {
+            customer_id: customer.id,
+            email: customer.email
+        });
+        return customer.id;
+    }
+    catch (error) {
+        // Update log record with error
+        Apilogger.updateResponse(logId, {
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+        throw error;
+    }
+});
+// Helper function to update subscription
+const updateSubscription = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const { subscriptionId, priceId, prorationBehavior = 'create_prorations' } = params;
+    const subscription = yield stripe.subscriptions.retrieve(subscriptionId);
+    // Create log record with request
+    const logId = yield Apilogger.logStripeOutgoing('updateSubscription', params);
+    try {
+        const updatedSubscription = yield stripe.subscriptions.update(subscriptionId, {
+            items: [
+                {
+                    id: subscription.items.data[0].id,
+                    price: priceId,
+                },
+            ],
+            proration_behavior: prorationBehavior,
+        });
+        // Update log record with response
+        Apilogger.updateResponse(logId, {
+            subscription_id: updatedSubscription.id,
+            status: updatedSubscription.status
+        });
+        return updatedSubscription;
+    }
+    catch (error) {
+        // Update log record with error
+        Apilogger.updateResponse(logId, {
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+        throw error;
+    }
+});
+const createCustomerPortalSession = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const logId = yield Apilogger.logStripeOutgoing('createCustomerPortalSession', params);
+    try {
+        const session = yield stripe.billingPortal.sessions.create({
+            customer: params.customerId,
+            return_url: params.returnUrl,
+        });
+        Apilogger.updateResponse(logId, {
+            session_id: session.id,
+            url: session.url,
+        });
+        return session;
+    }
+    catch (error) {
+        Apilogger.updateResponse(logId, {
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+        throw error;
+    }
+});
+// Helper function to cancel subscription
+const cancelSubscription = (subscriptionId_1, ...args_1) => __awaiter(void 0, [subscriptionId_1, ...args_1], void 0, function* (subscriptionId, cancelAtPeriodEnd = true) {
+    // Create log record with request
+    const logId = yield Apilogger.logStripeOutgoing('cancelSubscription', {
+        subscriptionId,
+        cancelAtPeriodEnd
+    });
+    try {
+        let result;
+        if (cancelAtPeriodEnd) {
+            result = yield stripe.subscriptions.update(subscriptionId, {
+                cancel_at_period_end: true,
+            });
+        }
+        else {
+            result = yield stripe.subscriptions.cancel(subscriptionId);
+        }
+        // Update log record with response
+        Apilogger.updateResponse(logId, {
+            subscription_id: result.id,
+            status: result.status,
+            cancel_at_period_end: result.cancel_at_period_end
+        });
+        return result;
+    }
+    catch (error) {
+        // Update log record with error
+        Apilogger.updateResponse(logId, {
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+        throw error;
+    }
+});
+class ActiveSubscriptionExistsError extends Error {
+    constructor() {
+        super('ACTIVE_SUBSCRIPTION_EXISTS');
+        this.name = 'ActiveSubscriptionExistsError';
+    }
+}
+
+export { ActiveSubscriptionExistsError, cancelSubscription, createCheckoutSession, createCustomerPortalSession, createOrGetCustomer, fetchPaymentId, stripe, updateSubscription, validateStripeWebhook };

package/dist/node_modules/.pnpm/@rollup_plugin-typescript@12.1.4_rollup@4.46.2_tslib@2.8.1_typescript@5.9.3/node_modules/tslib/tslib.es6.js

@@ -0,0 +1,48 @@
+'use strict';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+exports.__awaiter = __awaiter;
+exports.__rest = __rest;

package/dist/node_modules/.pnpm/@rollup_plugin-typescript@12.1.4_rollup@4.46.2_tslib@2.8.1_typescript@5.9.3/node_modules/tslib/tslib.es6.mjs

@@ -0,0 +1,45 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+export { __awaiter, __rest };

package/dist/node_modules/.pnpm/zod@4.1.12/node_modules/zod/v4/classic/errors.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var core = require('../core/core.js');
+var errors = require('../core/errors.js');
+var util = require('../core/util.js');
+
+const initializer = (inst, issues) => {
+    errors.$ZodError.init(inst, issues);
+    inst.name = "ZodError";
+    Object.defineProperties(inst, {
+        format: {
+            value: (mapper) => errors.formatError(inst, mapper),
+            // enumerable: false,
+        },
+        flatten: {
+            value: (mapper) => errors.flattenError(inst, mapper),
+            // enumerable: false,
+        },
+        addIssue: {
+            value: (issue) => {
+                inst.issues.push(issue);
+                inst.message = JSON.stringify(inst.issues, util.jsonStringifyReplacer, 2);
+            },
+            // enumerable: false,
+        },
+        addIssues: {
+            value: (issues) => {
+                inst.issues.push(...issues);
+                inst.message = JSON.stringify(inst.issues, util.jsonStringifyReplacer, 2);
+            },
+            // enumerable: false,
+        },
+        isEmpty: {
+            get() {
+                return inst.issues.length === 0;
+            },
+            // enumerable: false,
+        },
+    });
+    // Object.defineProperty(inst, "isEmpty", {
+    //   get() {
+    //     return inst.issues.length === 0;
+    //   },
+    // });
+};
+const ZodError = core.$constructor("ZodError", initializer);
+const ZodRealError = core.$constructor("ZodError", initializer, {
+    Parent: Error,
+});
+// /** @deprecated Use `z.core.$ZodErrorMapCtx` instead. */
+// export type ErrorMapCtx = core.$ZodErrorMapCtx;
+
+exports.ZodError = ZodError;
+exports.ZodRealError = ZodRealError;

package/dist/node_modules/.pnpm/zod@4.1.12/node_modules/zod/v4/classic/errors.mjs

@@ -0,0 +1,51 @@
+import { $constructor } from '../core/core.mjs';
+import { $ZodError, flattenError, formatError } from '../core/errors.mjs';
+import { jsonStringifyReplacer } from '../core/util.mjs';
+
+const initializer = (inst, issues) => {
+    $ZodError.init(inst, issues);
+    inst.name = "ZodError";
+    Object.defineProperties(inst, {
+        format: {
+            value: (mapper) => formatError(inst, mapper),
+            // enumerable: false,
+        },
+        flatten: {
+            value: (mapper) => flattenError(inst, mapper),
+            // enumerable: false,
+        },
+        addIssue: {
+            value: (issue) => {
+                inst.issues.push(issue);
+                inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+            },
+            // enumerable: false,
+        },
+        addIssues: {
+            value: (issues) => {
+                inst.issues.push(...issues);
+                inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+            },
+            // enumerable: false,
+        },
+        isEmpty: {
+            get() {
+                return inst.issues.length === 0;
+            },
+            // enumerable: false,
+        },
+    });
+    // Object.defineProperty(inst, "isEmpty", {
+    //   get() {
+    //     return inst.issues.length === 0;
+    //   },
+    // });
+};
+const ZodError = $constructor("ZodError", initializer);
+const ZodRealError = $constructor("ZodError", initializer, {
+    Parent: Error,
+});
+// /** @deprecated Use `z.core.$ZodErrorMapCtx` instead. */
+// export type ErrorMapCtx = core.$ZodErrorMapCtx;
+
+export { ZodError, ZodRealError };

package/dist/node_modules/.pnpm/zod@4.1.12/node_modules/zod/v4/classic/iso.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var core = require('../core/core.js');
+var schemas = require('../core/schemas.js');
+var api = require('../core/api.js');
+var schemas$1 = require('./schemas.js');
+
+const ZodISODateTime = /*@__PURE__*/ core.$constructor("ZodISODateTime", (inst, def) => {
+    schemas.$ZodISODateTime.init(inst, def);
+    schemas$1.ZodStringFormat.init(inst, def);
+});
+function datetime(params) {
+    return api._isoDateTime(ZodISODateTime, params);
+}
+const ZodISODate = /*@__PURE__*/ core.$constructor("ZodISODate", (inst, def) => {
+    schemas.$ZodISODate.init(inst, def);
+    schemas$1.ZodStringFormat.init(inst, def);
+});
+function date(params) {
+    return api._isoDate(ZodISODate, params);
+}
+const ZodISOTime = /*@__PURE__*/ core.$constructor("ZodISOTime", (inst, def) => {
+    schemas.$ZodISOTime.init(inst, def);
+    schemas$1.ZodStringFormat.init(inst, def);
+});
+function time(params) {
+    return api._isoTime(ZodISOTime, params);
+}
+const ZodISODuration = /*@__PURE__*/ core.$constructor("ZodISODuration", (inst, def) => {
+    schemas.$ZodISODuration.init(inst, def);
+    schemas$1.ZodStringFormat.init(inst, def);
+});
+function duration(params) {
+    return api._isoDuration(ZodISODuration, params);
+}
+
+exports.ZodISODate = ZodISODate;
+exports.ZodISODateTime = ZodISODateTime;
+exports.ZodISODuration = ZodISODuration;
+exports.ZodISOTime = ZodISOTime;
+exports.date = date;
+exports.datetime = datetime;
+exports.duration = duration;
+exports.time = time;

package/dist/node_modules/.pnpm/zod@4.1.12/node_modules/zod/v4/classic/iso.mjs

@@ -0,0 +1,35 @@
+import { $constructor } from '../core/core.mjs';
+import { $ZodISODateTime, $ZodISODate, $ZodISOTime, $ZodISODuration } from '../core/schemas.mjs';
+import { _isoDateTime, _isoDate, _isoTime, _isoDuration } from '../core/api.mjs';
+import { ZodStringFormat } from './schemas.mjs';
+
+const ZodISODateTime = /*@__PURE__*/ $constructor("ZodISODateTime", (inst, def) => {
+    $ZodISODateTime.init(inst, def);
+    ZodStringFormat.init(inst, def);
+});
+function datetime(params) {
+    return _isoDateTime(ZodISODateTime, params);
+}
+const ZodISODate = /*@__PURE__*/ $constructor("ZodISODate", (inst, def) => {
+    $ZodISODate.init(inst, def);
+    ZodStringFormat.init(inst, def);
+});
+function date(params) {
+    return _isoDate(ZodISODate, params);
+}
+const ZodISOTime = /*@__PURE__*/ $constructor("ZodISOTime", (inst, def) => {
+    $ZodISOTime.init(inst, def);
+    ZodStringFormat.init(inst, def);
+});
+function time(params) {
+    return _isoTime(ZodISOTime, params);
+}
+const ZodISODuration = /*@__PURE__*/ $constructor("ZodISODuration", (inst, def) => {
+    $ZodISODuration.init(inst, def);
+    ZodStringFormat.init(inst, def);
+});
+function duration(params) {
+    return _isoDuration(ZodISODuration, params);
+}
+
+export { ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime, date, datetime, duration, time };

package/dist/node_modules/.pnpm/zod@4.1.12/node_modules/zod/v4/classic/parse.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var parse$1 = require('../core/parse.js');
+var errors = require('./errors.js');
+
+const parse = /* @__PURE__ */ parse$1._parse(errors.ZodRealError);
+const parseAsync = /* @__PURE__ */ parse$1._parseAsync(errors.ZodRealError);
+const safeParse = /* @__PURE__ */ parse$1._safeParse(errors.ZodRealError);
+const safeParseAsync = /* @__PURE__ */ parse$1._safeParseAsync(errors.ZodRealError);
+// Codec functions
+const encode = /* @__PURE__ */ parse$1._encode(errors.ZodRealError);
+const decode = /* @__PURE__ */ parse$1._decode(errors.ZodRealError);
+const encodeAsync = /* @__PURE__ */ parse$1._encodeAsync(errors.ZodRealError);
+const decodeAsync = /* @__PURE__ */ parse$1._decodeAsync(errors.ZodRealError);
+const safeEncode = /* @__PURE__ */ parse$1._safeEncode(errors.ZodRealError);
+const safeDecode = /* @__PURE__ */ parse$1._safeDecode(errors.ZodRealError);
+const safeEncodeAsync = /* @__PURE__ */ parse$1._safeEncodeAsync(errors.ZodRealError);
+const safeDecodeAsync = /* @__PURE__ */ parse$1._safeDecodeAsync(errors.ZodRealError);
+
+exports.decode = decode;
+exports.decodeAsync = decodeAsync;
+exports.encode = encode;
+exports.encodeAsync = encodeAsync;
+exports.parse = parse;
+exports.parseAsync = parseAsync;
+exports.safeDecode = safeDecode;
+exports.safeDecodeAsync = safeDecodeAsync;
+exports.safeEncode = safeEncode;
+exports.safeEncodeAsync = safeEncodeAsync;
+exports.safeParse = safeParse;
+exports.safeParseAsync = safeParseAsync;

package/dist/node_modules/.pnpm/zod@4.1.12/node_modules/zod/v4/classic/parse.mjs

@@ -0,0 +1,18 @@
+import { _parse, _safeParse, _parseAsync, _safeParseAsync, _encode, _decode, _encodeAsync, _decodeAsync, _safeEncode, _safeDecode, _safeEncodeAsync, _safeDecodeAsync } from '../core/parse.mjs';
+import { ZodRealError } from './errors.mjs';
+
+const parse = /* @__PURE__ */ _parse(ZodRealError);
+const parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
+const safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
+const safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
+// Codec functions
+const encode = /* @__PURE__ */ _encode(ZodRealError);
+const decode = /* @__PURE__ */ _decode(ZodRealError);
+const encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
+const decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
+const safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
+const safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
+const safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
+const safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
+
+export { decode, decodeAsync, encode, encodeAsync, parse, parseAsync, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync };