@long2ice/relayx-backend 0.0.1

package/dist/generated/prisma/zod/index.d.ts

@@ -0,0 +1,2289 @@
+import { z } from 'zod';
+import { Prisma } from '../client';
+export type NullableJsonInput = Prisma.JsonValue | null | 'JsonNull' | 'DbNull' | Prisma.NullTypes.DbNull | Prisma.NullTypes.JsonNull;
+export declare const transformJsonNull: (v?: NullableJsonInput) => string | number | true | Prisma.JsonObject | Prisma.JsonArray | Prisma.NullTypes.DbNull | Prisma.NullTypes.JsonNull;
+export declare const JsonValueSchema: z.ZodType<Prisma.JsonValue>;
+export type JsonValueType = z.infer<typeof JsonValueSchema>;
+export declare const NullableJsonValue: z.ZodEffects<z.ZodNullable<z.ZodUnion<[z.ZodType<Prisma.JsonValue, z.ZodTypeDef, Prisma.JsonValue>, z.ZodLiteral<"DbNull">, z.ZodLiteral<"JsonNull">]>>, string | number | true | Prisma.JsonObject | Prisma.JsonArray | Prisma.NullTypes.DbNull | Prisma.NullTypes.JsonNull, Prisma.JsonValue>;
+export type NullableJsonValueType = z.infer<typeof NullableJsonValue>;
+export declare const InputJsonValueSchema: z.ZodType<Prisma.InputJsonValue>;
+export type InputJsonValueType = z.infer<typeof InputJsonValueSchema>;
+export declare const TransactionIsolationLevelSchema: z.ZodEnum<["ReadUncommitted", "ReadCommitted", "RepeatableRead", "Serializable"]>;
+export declare const NodeGroupScalarFieldEnumSchema: z.ZodEnum<["id", "token", "name", "port_range", "connect_ip", "node_type", "load_balance_type", "allow_listen_protocol", "allow_tunnel_types", "bypass_type", "bypass_list", "admission", "block_protocols", "traffic_rate", "need_out_node_group", "allow_out_node_groups", "allow_in_node_groups", "order_by", "created_at", "updated_at", "user_id"]>;
+export declare const NodeScalarFieldEnumSchema: z.ZodEnum<["id", "weight", "status", "node_id", "connect_ip", "version", "backup", "order_by", "custom_line", "dns_status", "created_at", "updated_at", "node_group_id"]>;
+export declare const TunnelScalarFieldEnumSchema: z.ZodEnum<["id", "name", "tunnel_type", "category", "listen_ip", "listen_port", "listen_protocol", "is_port_used", "status", "white_list", "forward_addresses", "forward_addresses_protocol", "load_balance_type", "ip_type", "order_by", "ip_limit", "bandwidth_limit", "traffic", "traffic_cost", "stats", "proxy_protocol", "created_at", "updated_at", "in_node_group_id", "out_node_group_id", "user_id"]>;
+export declare const TunnelChainScalarFieldEnumSchema: z.ZodEnum<["id", "tunnel_id", "node_type", "node_group_id"]>;
+export declare const UserScalarFieldEnumSchema: z.ZodEnum<["id", "super_admin", "email", "balance", "tg_id", "uid", "note", "parent_id", "referral_commission_rate", "referral_first_only", "auto_renew", "api_key", "notify_subscriptions", "status", "created_at", "updated_at"]>;
+export declare const UserPlanScalarFieldEnumSchema: z.ZodEnum<["id", "user_id", "traffic", "traffic_used", "max_tunnels", "expired_at", "created_at", "updated_at", "plan_id"]>;
+export declare const PlanScalarFieldEnumSchema: z.ZodEnum<["id", "name", "description", "original_price", "price", "max_tunnels", "traffic", "ip_limit", "bandwidth_limit", "allow_custom_in_node_group", "allow_custom_out_node_group", "all_in_node_groups", "all_out_node_groups", "setup_fee", "billing_cycle", "status", "renewable", "stock", "order_by", "created_at", "updated_at"]>;
+export declare const PlanNodeGroupScalarFieldEnumSchema: z.ZodEnum<["id", "plan_id", "node_group_id", "created_at", "updated_at"]>;
+export declare const PlanOrderScalarFieldEnumSchema: z.ZodEnum<["id", "user_id", "plan_id", "price", "balance", "coupon_id", "created_at", "updated_at"]>;
+export declare const TopupOrderScalarFieldEnumSchema: z.ZodEnum<["id", "user_id", "price", "balance", "bonus", "payment_id", "pay_url", "status", "order_id", "trade_id", "created_at", "updated_at"]>;
+export declare const TopupActivityScalarFieldEnumSchema: z.ZodEnum<["id", "type", "value", "min_amount", "max_amount", "valid_start", "valid_end", "created_at", "updated_at"]>;
+export declare const TunnelTrafficScalarFieldEnumSchema: z.ZodEnum<["id", "tunnel_id", "traffic", "traffic_cost", "date"]>;
+export declare const SystemConfigScalarFieldEnumSchema: z.ZodEnum<["id", "name", "value", "created_at", "updated_at"]>;
+export declare const PaymentScalarFieldEnumSchema: z.ZodEnum<["id", "fixed_fee", "percent_fee", "name", "url", "config", "method", "type", "status", "order_by", "created_at", "updated_at"]>;
+export declare const PlanCouponScalarFieldEnumSchema: z.ZodEnum<["id", "code", "type", "valid_cycle", "value", "valid_start", "valid_end", "max_use", "max_use_per_user", "created_at", "updated_at"]>;
+export declare const BalanceLogScalarFieldEnumSchema: z.ZodEnum<["id", "user_id", "balance", "amount", "type", "created_at", "updated_at"]>;
+export declare const TicketScalarFieldEnumSchema: z.ZodEnum<["id", "title", "content", "status", "user_id", "created_at", "updated_at"]>;
+export declare const TicketReplyScalarFieldEnumSchema: z.ZodEnum<["id", "content", "is_admin", "ticket_id", "user_id", "created_at", "updated_at"]>;
+export declare const InNodeGroupDNSScalarFieldEnumSchema: z.ZodEnum<["id", "in_node_group_id", "dns_provider_id", "ttl", "ipv6", "status", "created_at", "updated_at"]>;
+export declare const DNSProviderScalarFieldEnumSchema: z.ZodEnum<["id", "name", "type", "config", "created_at", "updated_at"]>;
+export declare const SortOrderSchema: z.ZodEnum<["asc", "desc"]>;
+export declare const NullableJsonNullValueInputSchema: z.ZodEffects<z.ZodEnum<["DbNull", "JsonNull"]>, Prisma.NullTypes.DbNull | Prisma.NullTypes.JsonNull, "JsonNull" | "DbNull">;
+export declare const JsonNullValueInputSchema: z.ZodEffects<z.ZodEnum<["JsonNull"]>, Prisma.NullTypes.JsonNull, "JsonNull">;
+export declare const JsonNullValueFilterSchema: z.ZodEffects<z.ZodEnum<["DbNull", "JsonNull", "AnyNull"]>, Prisma.NullTypes.JsonNull | Prisma.NullTypes.AnyNull, "JsonNull" | "DbNull" | "AnyNull">;
+export declare const QueryModeSchema: z.ZodEnum<["default", "insensitive"]>;
+export declare const NullsOrderSchema: z.ZodEnum<["first", "last"]>;
+export declare const NodeGroupOrderByRelevanceFieldEnumSchema: z.ZodEnum<["token", "name", "port_range", "connect_ip"]>;
+export declare const NodeOrderByRelevanceFieldEnumSchema: z.ZodEnum<["node_id", "connect_ip", "version", "custom_line"]>;
+export declare const TunnelOrderByRelevanceFieldEnumSchema: z.ZodEnum<["name", "listen_ip"]>;
+export declare const UserOrderByRelevanceFieldEnumSchema: z.ZodEnum<["email", "tg_id", "uid", "note", "api_key"]>;
+export declare const PlanOrderByRelevanceFieldEnumSchema: z.ZodEnum<["name", "description"]>;
+export declare const TopupOrderOrderByRelevanceFieldEnumSchema: z.ZodEnum<["pay_url", "order_id", "trade_id"]>;
+export declare const SystemConfigOrderByRelevanceFieldEnumSchema: z.ZodEnum<["value"]>;
+export declare const PaymentOrderByRelevanceFieldEnumSchema: z.ZodEnum<["name", "url", "type"]>;
+export declare const PlanCouponOrderByRelevanceFieldEnumSchema: z.ZodEnum<["code"]>;
+export declare const TicketOrderByRelevanceFieldEnumSchema: z.ZodEnum<["title", "content"]>;
+export declare const TicketReplyOrderByRelevanceFieldEnumSchema: z.ZodEnum<["content"]>;
+export declare const DNSProviderOrderByRelevanceFieldEnumSchema: z.ZodEnum<["name"]>;
+export declare const NodeTypeSchema: z.ZodEnum<["in", "out"]>;
+export type NodeTypeType = `${z.infer<typeof NodeTypeSchema>}`;
+export declare const StatusSchema: z.ZodEnum<["active", "inactive"]>;
+export type StatusType = `${z.infer<typeof StatusSchema>}`;
+export declare const BypassTypeSchema: z.ZodEnum<["whitelist", "blacklist"]>;
+export type BypassTypeType = `${z.infer<typeof BypassTypeSchema>}`;
+export declare const LoadBalanceTypeSchema: z.ZodEnum<["round", "rand", "fifo", "hash", "ll", "lc"]>;
+export type LoadBalanceTypeType = `${z.infer<typeof LoadBalanceTypeSchema>}`;
+export declare const TunnelTypeSchema: z.ZodEnum<["tcp", "mtcp", "udp", "relayx", "mtls", "mwss", "wss", "tls", "quic"]>;
+export type TunnelTypeType = `${z.infer<typeof TunnelTypeSchema>}`;
+export declare const IpTypeSchema: z.ZodEnum<["auto", "ipv4", "ipv6"]>;
+export type IpTypeType = `${z.infer<typeof IpTypeSchema>}`;
+export declare const TunnelCategorySchema: z.ZodEnum<["port_forward", "remote_port_forward"]>;
+export type TunnelCategoryType = `${z.infer<typeof TunnelCategorySchema>}`;
+export declare const BillingCycleSchema: z.ZodEnum<["month", "quarter", "half_year", "year", "lifetime"]>;
+export type BillingCycleType = `${z.infer<typeof BillingCycleSchema>}`;
+export declare const TopupOrderStatusSchema: z.ZodEnum<["pending", "success", "cancelled"]>;
+export type TopupOrderStatusType = `${z.infer<typeof TopupOrderStatusSchema>}`;
+export declare const TopupActivityTypeSchema: z.ZodEnum<["percentage", "fixed"]>;
+export type TopupActivityTypeType = `${z.infer<typeof TopupActivityTypeSchema>}`;
+export declare const SystemConfigNameSchema: z.ZodEnum<["MIN_TOPUP_AMOUNT", "NOTICE", "NOTICE_POPUP", "NOTICE_POPUP_INTERVAL_HOURS", "SITE_NAME", "SITE_DESCRIPTION", "ALLOW_REGISTER", "LOGO_URL", "HIDE_NODE_STATUS", "AUTO_UPDATE_AGENT", "CHATWOOT_BASE_URL", "CHATWOOT_TOKEN", "TUNNEL_TRAFFIC_RETENTION_DAYS", "HIDE_FOOTER", "HIDE_DOCS", "LANDING_PAGE_URL", "REFERRAL_COMMISSION_RATE", "REFERRAL_FIRST_ONLY", "REFERRAL_MODE", "OBSERVER_PERIOD", "EMAIL_PROVIDER", "SMTP_HOST", "SMTP_PORT", "SMTP_SECURE", "SMTP_USER", "SMTP_PASS", "SMTP_FROM", "RESEND_API_KEY", "RESEND_FROM"]>;
+export type SystemConfigNameType = `${z.infer<typeof SystemConfigNameSchema>}`;
+export declare const PaymentMethodSchema: z.ZodEnum<["epay", "bepusdt", "heleket"]>;
+export type PaymentMethodType = `${z.infer<typeof PaymentMethodSchema>}`;
+export declare const CouponTypeSchema: z.ZodEnum<["percentage", "fixed"]>;
+export type CouponTypeType = `${z.infer<typeof CouponTypeSchema>}`;
+export declare const BalanceLogTypeSchema: z.ZodEnum<["topup", "plan", "referral"]>;
+export type BalanceLogTypeType = `${z.infer<typeof BalanceLogTypeSchema>}`;
+export declare const TicketStatusSchema: z.ZodEnum<["open", "closed"]>;
+export type TicketStatusType = `${z.infer<typeof TicketStatusSchema>}`;
+export declare const DNSProviderTypeSchema: z.ZodEnum<["cloudflare", "huawei"]>;
+export type DNSProviderTypeType = `${z.infer<typeof DNSProviderTypeSchema>}`;
+export declare const NodeGroupSchema: z.ZodObject<{
+    node_type: z.ZodEnum<["in", "out"]>;
+    load_balance_type: z.ZodEnum<["round", "rand", "fifo", "hash", "ll", "lc"]>;
+    bypass_type: z.ZodEnum<["whitelist", "blacklist"]>;
+    id: z.ZodNumber;
+    token: z.ZodString;
+    name: z.ZodString;
+    port_range: z.ZodNullable<z.ZodString>;
+    connect_ip: z.ZodNullable<z.ZodString>;
+    allow_listen_protocol: z.ZodBoolean;
+    allow_tunnel_types: z.ZodNullable<z.ZodType<Prisma.JsonValue, z.ZodTypeDef, Prisma.JsonValue>>;
+    bypass_list: z.ZodNullable<z.ZodType<Prisma.JsonValue, z.ZodTypeDef, Prisma.JsonValue>>;
+    admission: z.ZodBoolean;
+    block_protocols: z.ZodNullable<z.ZodType<Prisma.JsonValue, z.ZodTypeDef, Prisma.JsonValue>>;
+    traffic_rate: z.ZodNumber;
+    need_out_node_group: z.ZodBoolean;
+    allow_out_node_groups: z.ZodNullable<z.ZodType<Prisma.JsonValue, z.ZodTypeDef, Prisma.JsonValue>>;
+    allow_in_node_groups: z.ZodNullable<z.ZodType<Prisma.JsonValue, z.ZodTypeDef, Prisma.JsonValue>>;
+    order_by: z.ZodNumber;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+    user_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: number;
+    token: string;
+    port_range: string | null;
+    connect_ip: string | null;
+    node_type: "in" | "out";
+    load_balance_type: "round" | "rand" | "fifo" | "hash" | "ll" | "lc";
+    allow_listen_protocol: boolean;
+    allow_tunnel_types: Prisma.JsonValue;
+    bypass_type: "whitelist" | "blacklist";
+    bypass_list: Prisma.JsonValue;
+    admission: boolean;
+    block_protocols: Prisma.JsonValue;
+    traffic_rate: number;
+    need_out_node_group: boolean;
+    allow_out_node_groups: Prisma.JsonValue;
+    allow_in_node_groups: Prisma.JsonValue;
+    order_by: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+}, {
+    name: string;
+    id: number;
+    token: string;
+    port_range: string | null;
+    connect_ip: string | null;
+    node_type: "in" | "out";
+    load_balance_type: "round" | "rand" | "fifo" | "hash" | "ll" | "lc";
+    allow_listen_protocol: boolean;
+    allow_tunnel_types: Prisma.JsonValue;
+    bypass_type: "whitelist" | "blacklist";
+    bypass_list: Prisma.JsonValue;
+    admission: boolean;
+    block_protocols: Prisma.JsonValue;
+    traffic_rate: number;
+    need_out_node_group: boolean;
+    allow_out_node_groups: Prisma.JsonValue;
+    allow_in_node_groups: Prisma.JsonValue;
+    order_by: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+}>;
+export type NodeGroup = z.infer<typeof NodeGroupSchema>;
+export declare const NodeSchema: z.ZodObject<{
+    status: z.ZodEnum<["active", "inactive"]>;
+    id: z.ZodNumber;
+    weight: z.ZodNumber;
+    node_id: z.ZodString;
+    connect_ip: z.ZodString;
+    version: z.ZodString;
+    backup: z.ZodBoolean;
+    order_by: z.ZodNumber;
+    custom_line: z.ZodNullable<z.ZodString>;
+    dns_status: z.ZodBoolean;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+    node_group_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    connect_ip: string;
+    order_by: number;
+    created_at: Date;
+    updated_at: Date;
+    status: "active" | "inactive";
+    weight: number;
+    node_id: string;
+    version: string;
+    backup: boolean;
+    custom_line: string | null;
+    dns_status: boolean;
+    node_group_id: number;
+}, {
+    id: number;
+    connect_ip: string;
+    order_by: number;
+    created_at: Date;
+    updated_at: Date;
+    status: "active" | "inactive";
+    weight: number;
+    node_id: string;
+    version: string;
+    backup: boolean;
+    custom_line: string | null;
+    dns_status: boolean;
+    node_group_id: number;
+}>;
+export type Node = z.infer<typeof NodeSchema>;
+export declare const TunnelSchema: z.ZodObject<{
+    tunnel_type: z.ZodEnum<["tcp", "mtcp", "udp", "relayx", "mtls", "mwss", "wss", "tls", "quic"]>;
+    category: z.ZodEnum<["port_forward", "remote_port_forward"]>;
+    status: z.ZodEnum<["active", "inactive"]>;
+    load_balance_type: z.ZodEnum<["round", "rand", "fifo", "hash", "ll", "lc"]>;
+    ip_type: z.ZodEnum<["auto", "ipv4", "ipv6"]>;
+    id: z.ZodNumber;
+    name: z.ZodString;
+    listen_ip: z.ZodNullable<z.ZodString>;
+    listen_port: z.ZodNullable<z.ZodNumber>;
+    listen_protocol: z.ZodNullable<z.ZodType<Prisma.JsonValue, z.ZodTypeDef, Prisma.JsonValue>>;
+    is_port_used: z.ZodBoolean;
+    white_list: z.ZodNullable<z.ZodType<Prisma.JsonValue, z.ZodTypeDef, Prisma.JsonValue>>;
+    forward_addresses: z.ZodType<Prisma.JsonValue, z.ZodTypeDef, Prisma.JsonValue>;
+    forward_addresses_protocol: z.ZodNullable<z.ZodType<Prisma.JsonValue, z.ZodTypeDef, Prisma.JsonValue>>;
+    order_by: z.ZodNumber;
+    ip_limit: z.ZodNullable<z.ZodNumber>;
+    bandwidth_limit: z.ZodNullable<z.ZodNumber>;
+    traffic: z.ZodNumber;
+    traffic_cost: z.ZodNumber;
+    stats: z.ZodNullable<z.ZodType<Prisma.JsonValue, z.ZodTypeDef, Prisma.JsonValue>>;
+    proxy_protocol: z.ZodBoolean;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+    in_node_group_id: z.ZodNumber;
+    out_node_group_id: z.ZodNullable<z.ZodNumber>;
+    user_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: number;
+    load_balance_type: "round" | "rand" | "fifo" | "hash" | "ll" | "lc";
+    order_by: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+    status: "active" | "inactive";
+    tunnel_type: "tcp" | "mtcp" | "udp" | "relayx" | "mtls" | "mwss" | "wss" | "tls" | "quic";
+    category: "port_forward" | "remote_port_forward";
+    listen_ip: string | null;
+    listen_port: number | null;
+    listen_protocol: Prisma.JsonValue;
+    is_port_used: boolean;
+    white_list: Prisma.JsonValue;
+    forward_addresses: Prisma.JsonValue;
+    forward_addresses_protocol: Prisma.JsonValue;
+    ip_type: "auto" | "ipv4" | "ipv6";
+    ip_limit: number | null;
+    bandwidth_limit: number | null;
+    traffic: number;
+    traffic_cost: number;
+    stats: Prisma.JsonValue;
+    proxy_protocol: boolean;
+    in_node_group_id: number;
+    out_node_group_id: number | null;
+}, {
+    name: string;
+    id: number;
+    load_balance_type: "round" | "rand" | "fifo" | "hash" | "ll" | "lc";
+    order_by: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+    status: "active" | "inactive";
+    tunnel_type: "tcp" | "mtcp" | "udp" | "relayx" | "mtls" | "mwss" | "wss" | "tls" | "quic";
+    category: "port_forward" | "remote_port_forward";
+    listen_ip: string | null;
+    listen_port: number | null;
+    listen_protocol: Prisma.JsonValue;
+    is_port_used: boolean;
+    white_list: Prisma.JsonValue;
+    forward_addresses: Prisma.JsonValue;
+    forward_addresses_protocol: Prisma.JsonValue;
+    ip_type: "auto" | "ipv4" | "ipv6";
+    ip_limit: number | null;
+    bandwidth_limit: number | null;
+    traffic: number;
+    traffic_cost: number;
+    stats: Prisma.JsonValue;
+    proxy_protocol: boolean;
+    in_node_group_id: number;
+    out_node_group_id: number | null;
+}>;
+export type Tunnel = z.infer<typeof TunnelSchema>;
+export declare const TunnelChainSchema: z.ZodObject<{
+    node_type: z.ZodEnum<["in", "out"]>;
+    id: z.ZodNumber;
+    tunnel_id: z.ZodNumber;
+    node_group_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    node_type: "in" | "out";
+    node_group_id: number;
+    tunnel_id: number;
+}, {
+    id: number;
+    node_type: "in" | "out";
+    node_group_id: number;
+    tunnel_id: number;
+}>;
+export type TunnelChain = z.infer<typeof TunnelChainSchema>;
+export declare const UserSchema: z.ZodObject<{
+    status: z.ZodEnum<["active", "inactive"]>;
+    id: z.ZodNumber;
+    super_admin: z.ZodBoolean;
+    email: z.ZodString;
+    balance: z.ZodNumber;
+    tg_id: z.ZodNullable<z.ZodString>;
+    uid: z.ZodNullable<z.ZodString>;
+    note: z.ZodNullable<z.ZodString>;
+    parent_id: z.ZodNullable<z.ZodNumber>;
+    referral_commission_rate: z.ZodNullable<z.ZodNumber>;
+    referral_first_only: z.ZodNullable<z.ZodBoolean>;
+    auto_renew: z.ZodBoolean;
+    api_key: z.ZodString;
+    notify_subscriptions: z.ZodNullable<z.ZodType<Prisma.JsonValue, z.ZodTypeDef, Prisma.JsonValue>>;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    super_admin: boolean;
+    email: string;
+    balance: number;
+    tg_id: string | null;
+    uid: string | null;
+    note: string | null;
+    parent_id: number | null;
+    referral_commission_rate: number | null;
+    referral_first_only: boolean | null;
+    auto_renew: boolean;
+    api_key: string;
+    notify_subscriptions: Prisma.JsonValue;
+    status: "active" | "inactive";
+}, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    super_admin: boolean;
+    email: string;
+    balance: number;
+    tg_id: string | null;
+    uid: string | null;
+    note: string | null;
+    parent_id: number | null;
+    referral_commission_rate: number | null;
+    referral_first_only: boolean | null;
+    auto_renew: boolean;
+    api_key: string;
+    notify_subscriptions: Prisma.JsonValue;
+    status: "active" | "inactive";
+}>;
+export type User = z.infer<typeof UserSchema>;
+export declare const UserPlanSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    user_id: z.ZodNumber;
+    traffic: z.ZodNullable<z.ZodNumber>;
+    traffic_used: z.ZodNumber;
+    max_tunnels: z.ZodNullable<z.ZodNumber>;
+    expired_at: z.ZodNullable<z.ZodDate>;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+    plan_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+    traffic: number | null;
+    plan_id: number;
+    traffic_used: number;
+    max_tunnels: number | null;
+    expired_at: Date | null;
+}, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+    traffic: number | null;
+    plan_id: number;
+    traffic_used: number;
+    max_tunnels: number | null;
+    expired_at: Date | null;
+}>;
+export type UserPlan = z.infer<typeof UserPlanSchema>;
+export declare const PlanSchema: z.ZodObject<{
+    billing_cycle: z.ZodEnum<["month", "quarter", "half_year", "year", "lifetime"]>;
+    status: z.ZodEnum<["active", "inactive"]>;
+    id: z.ZodNumber;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    original_price: z.ZodNullable<z.ZodNumber>;
+    price: z.ZodNumber;
+    max_tunnels: z.ZodNullable<z.ZodNumber>;
+    traffic: z.ZodNullable<z.ZodNumber>;
+    ip_limit: z.ZodNullable<z.ZodNumber>;
+    bandwidth_limit: z.ZodNullable<z.ZodNumber>;
+    allow_custom_in_node_group: z.ZodBoolean;
+    allow_custom_out_node_group: z.ZodBoolean;
+    all_in_node_groups: z.ZodBoolean;
+    all_out_node_groups: z.ZodBoolean;
+    setup_fee: z.ZodNullable<z.ZodNumber>;
+    renewable: z.ZodBoolean;
+    stock: z.ZodNullable<z.ZodNumber>;
+    order_by: z.ZodNumber;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: number;
+    order_by: number;
+    created_at: Date;
+    updated_at: Date;
+    status: "active" | "inactive";
+    ip_limit: number | null;
+    bandwidth_limit: number | null;
+    traffic: number | null;
+    price: number;
+    max_tunnels: number | null;
+    description: string | null;
+    original_price: number | null;
+    allow_custom_in_node_group: boolean;
+    allow_custom_out_node_group: boolean;
+    all_in_node_groups: boolean;
+    all_out_node_groups: boolean;
+    setup_fee: number | null;
+    billing_cycle: "month" | "quarter" | "half_year" | "year" | "lifetime";
+    renewable: boolean;
+    stock: number | null;
+}, {
+    name: string;
+    id: number;
+    order_by: number;
+    created_at: Date;
+    updated_at: Date;
+    status: "active" | "inactive";
+    ip_limit: number | null;
+    bandwidth_limit: number | null;
+    traffic: number | null;
+    price: number;
+    max_tunnels: number | null;
+    description: string | null;
+    original_price: number | null;
+    allow_custom_in_node_group: boolean;
+    allow_custom_out_node_group: boolean;
+    all_in_node_groups: boolean;
+    all_out_node_groups: boolean;
+    setup_fee: number | null;
+    billing_cycle: "month" | "quarter" | "half_year" | "year" | "lifetime";
+    renewable: boolean;
+    stock: number | null;
+}>;
+export type Plan = z.infer<typeof PlanSchema>;
+export declare const PlanNodeGroupSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    plan_id: z.ZodNumber;
+    node_group_id: z.ZodNumber;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    plan_id: number;
+    node_group_id: number;
+}, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    plan_id: number;
+    node_group_id: number;
+}>;
+export type PlanNodeGroup = z.infer<typeof PlanNodeGroupSchema>;
+export declare const PlanOrderSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    user_id: z.ZodNumber;
+    plan_id: z.ZodNumber;
+    price: z.ZodNumber;
+    balance: z.ZodNumber;
+    coupon_id: z.ZodNullable<z.ZodNumber>;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+    balance: number;
+    plan_id: number;
+    price: number;
+    coupon_id: number | null;
+}, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+    balance: number;
+    plan_id: number;
+    price: number;
+    coupon_id: number | null;
+}>;
+export type PlanOrder = z.infer<typeof PlanOrderSchema>;
+export declare const TopupOrderSchema: z.ZodObject<{
+    status: z.ZodEnum<["pending", "success", "cancelled"]>;
+    id: z.ZodNumber;
+    user_id: z.ZodNumber;
+    price: z.ZodNumber;
+    balance: z.ZodNumber;
+    bonus: z.ZodNumber;
+    payment_id: z.ZodNumber;
+    pay_url: z.ZodString;
+    order_id: z.ZodString;
+    trade_id: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+    balance: number;
+    status: "pending" | "success" | "cancelled";
+    price: number;
+    bonus: number;
+    payment_id: number;
+    pay_url: string;
+    order_id: string;
+    trade_id: string | null;
+}, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+    balance: number;
+    status: "pending" | "success" | "cancelled";
+    price: number;
+    bonus: number;
+    payment_id: number;
+    pay_url: string;
+    order_id: string;
+    trade_id: string | null;
+}>;
+export type TopupOrder = z.infer<typeof TopupOrderSchema>;
+export declare const TopupActivitySchema: z.ZodObject<{
+    type: z.ZodEnum<["percentage", "fixed"]>;
+    id: z.ZodNumber;
+    value: z.ZodNumber;
+    min_amount: z.ZodNullable<z.ZodNumber>;
+    max_amount: z.ZodNullable<z.ZodNumber>;
+    valid_start: z.ZodNullable<z.ZodDate>;
+    valid_end: z.ZodNullable<z.ZodDate>;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    type: "fixed" | "percentage";
+    value: number;
+    min_amount: number | null;
+    max_amount: number | null;
+    valid_start: Date | null;
+    valid_end: Date | null;
+}, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    type: "fixed" | "percentage";
+    value: number;
+    min_amount: number | null;
+    max_amount: number | null;
+    valid_start: Date | null;
+    valid_end: Date | null;
+}>;
+export type TopupActivity = z.infer<typeof TopupActivitySchema>;
+export declare const TunnelTrafficSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    tunnel_id: z.ZodNumber;
+    traffic: z.ZodNumber;
+    traffic_cost: z.ZodNumber;
+    date: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    traffic: number;
+    traffic_cost: number;
+    tunnel_id: number;
+    date: Date;
+}, {
+    id: number;
+    traffic: number;
+    traffic_cost: number;
+    tunnel_id: number;
+    date: Date;
+}>;
+export type TunnelTraffic = z.infer<typeof TunnelTrafficSchema>;
+export declare const SystemConfigSchema: z.ZodObject<{
+    name: z.ZodEnum<["MIN_TOPUP_AMOUNT", "NOTICE", "NOTICE_POPUP", "NOTICE_POPUP_INTERVAL_HOURS", "SITE_NAME", "SITE_DESCRIPTION", "ALLOW_REGISTER", "LOGO_URL", "HIDE_NODE_STATUS", "AUTO_UPDATE_AGENT", "CHATWOOT_BASE_URL", "CHATWOOT_TOKEN", "TUNNEL_TRAFFIC_RETENTION_DAYS", "HIDE_FOOTER", "HIDE_DOCS", "LANDING_PAGE_URL", "REFERRAL_COMMISSION_RATE", "REFERRAL_FIRST_ONLY", "REFERRAL_MODE", "OBSERVER_PERIOD", "EMAIL_PROVIDER", "SMTP_HOST", "SMTP_PORT", "SMTP_SECURE", "SMTP_USER", "SMTP_PASS", "SMTP_FROM", "RESEND_API_KEY", "RESEND_FROM"]>;
+    id: z.ZodNumber;
+    value: z.ZodString;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    name: "MIN_TOPUP_AMOUNT" | "NOTICE" | "NOTICE_POPUP" | "NOTICE_POPUP_INTERVAL_HOURS" | "SITE_NAME" | "SITE_DESCRIPTION" | "ALLOW_REGISTER" | "LOGO_URL" | "HIDE_NODE_STATUS" | "AUTO_UPDATE_AGENT" | "CHATWOOT_BASE_URL" | "CHATWOOT_TOKEN" | "TUNNEL_TRAFFIC_RETENTION_DAYS" | "HIDE_FOOTER" | "HIDE_DOCS" | "LANDING_PAGE_URL" | "REFERRAL_COMMISSION_RATE" | "REFERRAL_FIRST_ONLY" | "REFERRAL_MODE" | "OBSERVER_PERIOD" | "EMAIL_PROVIDER" | "SMTP_HOST" | "SMTP_PORT" | "SMTP_SECURE" | "SMTP_USER" | "SMTP_PASS" | "SMTP_FROM" | "RESEND_API_KEY" | "RESEND_FROM";
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    value: string;
+}, {
+    name: "MIN_TOPUP_AMOUNT" | "NOTICE" | "NOTICE_POPUP" | "NOTICE_POPUP_INTERVAL_HOURS" | "SITE_NAME" | "SITE_DESCRIPTION" | "ALLOW_REGISTER" | "LOGO_URL" | "HIDE_NODE_STATUS" | "AUTO_UPDATE_AGENT" | "CHATWOOT_BASE_URL" | "CHATWOOT_TOKEN" | "TUNNEL_TRAFFIC_RETENTION_DAYS" | "HIDE_FOOTER" | "HIDE_DOCS" | "LANDING_PAGE_URL" | "REFERRAL_COMMISSION_RATE" | "REFERRAL_FIRST_ONLY" | "REFERRAL_MODE" | "OBSERVER_PERIOD" | "EMAIL_PROVIDER" | "SMTP_HOST" | "SMTP_PORT" | "SMTP_SECURE" | "SMTP_USER" | "SMTP_PASS" | "SMTP_FROM" | "RESEND_API_KEY" | "RESEND_FROM";
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    value: string;
+}>;
+export type SystemConfig = z.infer<typeof SystemConfigSchema>;
+export declare const PaymentSchema: z.ZodObject<{
+    method: z.ZodEnum<["epay", "bepusdt", "heleket"]>;
+    status: z.ZodEnum<["active", "inactive"]>;
+    id: z.ZodNumber;
+    fixed_fee: z.ZodNullable<z.ZodNumber>;
+    percent_fee: z.ZodNullable<z.ZodNumber>;
+    name: z.ZodString;
+    url: z.ZodString;
+    config: z.ZodType<Prisma.JsonValue, z.ZodTypeDef, Prisma.JsonValue>;
+    type: z.ZodNullable<z.ZodString>;
+    order_by: z.ZodNumber;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: number;
+    order_by: number;
+    created_at: Date;
+    updated_at: Date;
+    status: "active" | "inactive";
+    type: string | null;
+    fixed_fee: number | null;
+    percent_fee: number | null;
+    url: string;
+    config: Prisma.JsonValue;
+    method: "epay" | "bepusdt" | "heleket";
+}, {
+    name: string;
+    id: number;
+    order_by: number;
+    created_at: Date;
+    updated_at: Date;
+    status: "active" | "inactive";
+    type: string | null;
+    fixed_fee: number | null;
+    percent_fee: number | null;
+    url: string;
+    config: Prisma.JsonValue;
+    method: "epay" | "bepusdt" | "heleket";
+}>;
+export type Payment = z.infer<typeof PaymentSchema>;
+export declare const PlanCouponSchema: z.ZodObject<{
+    type: z.ZodEnum<["percentage", "fixed"]>;
+    valid_cycle: z.ZodNullable<z.ZodEnum<["month", "quarter", "half_year", "year", "lifetime"]>>;
+    id: z.ZodNumber;
+    code: z.ZodString;
+    value: z.ZodNumber;
+    valid_start: z.ZodNullable<z.ZodDate>;
+    valid_end: z.ZodNullable<z.ZodDate>;
+    max_use: z.ZodNullable<z.ZodNumber>;
+    max_use_per_user: z.ZodNullable<z.ZodNumber>;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    type: "fixed" | "percentage";
+    value: number;
+    code: string;
+    valid_start: Date | null;
+    valid_end: Date | null;
+    valid_cycle: "month" | "quarter" | "half_year" | "year" | "lifetime" | null;
+    max_use: number | null;
+    max_use_per_user: number | null;
+}, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    type: "fixed" | "percentage";
+    value: number;
+    code: string;
+    valid_start: Date | null;
+    valid_end: Date | null;
+    valid_cycle: "month" | "quarter" | "half_year" | "year" | "lifetime" | null;
+    max_use: number | null;
+    max_use_per_user: number | null;
+}>;
+export type PlanCoupon = z.infer<typeof PlanCouponSchema>;
+export declare const BalanceLogSchema: z.ZodObject<{
+    type: z.ZodEnum<["topup", "plan", "referral"]>;
+    id: z.ZodNumber;
+    user_id: z.ZodNumber;
+    balance: z.ZodNumber;
+    amount: z.ZodNumber;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+    balance: number;
+    amount: number;
+    type: "topup" | "plan" | "referral";
+}, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+    balance: number;
+    amount: number;
+    type: "topup" | "plan" | "referral";
+}>;
+export type BalanceLog = z.infer<typeof BalanceLogSchema>;
+export declare const TicketSchema: z.ZodObject<{
+    status: z.ZodEnum<["open", "closed"]>;
+    id: z.ZodNumber;
+    title: z.ZodString;
+    content: z.ZodString;
+    user_id: z.ZodNumber;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+    status: "open" | "closed";
+    title: string;
+    content: string;
+}, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+    status: "open" | "closed";
+    title: string;
+    content: string;
+}>;
+export type Ticket = z.infer<typeof TicketSchema>;
+export declare const TicketReplySchema: z.ZodObject<{
+    id: z.ZodNumber;
+    content: z.ZodString;
+    is_admin: z.ZodBoolean;
+    ticket_id: z.ZodNumber;
+    user_id: z.ZodNumber;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+    content: string;
+    is_admin: boolean;
+    ticket_id: number;
+}, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    user_id: number;
+    content: string;
+    is_admin: boolean;
+    ticket_id: number;
+}>;
+export type TicketReply = z.infer<typeof TicketReplySchema>;
+export declare const InNodeGroupDNSSchema: z.ZodObject<{
+    status: z.ZodEnum<["active", "inactive"]>;
+    id: z.ZodNumber;
+    in_node_group_id: z.ZodNumber;
+    dns_provider_id: z.ZodNumber;
+    ttl: z.ZodNumber;
+    ipv6: z.ZodBoolean;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    status: "active" | "inactive";
+    in_node_group_id: number;
+    ipv6: boolean;
+    dns_provider_id: number;
+    ttl: number;
+}, {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    status: "active" | "inactive";
+    in_node_group_id: number;
+    ipv6: boolean;
+    dns_provider_id: number;
+    ttl: number;
+}>;
+export type InNodeGroupDNS = z.infer<typeof InNodeGroupDNSSchema>;
+export declare const DNSProviderSchema: z.ZodObject<{
+    type: z.ZodEnum<["cloudflare", "huawei"]>;
+    id: z.ZodNumber;
+    name: z.ZodString;
+    config: z.ZodType<Prisma.JsonValue, z.ZodTypeDef, Prisma.JsonValue>;
+    created_at: z.ZodDate;
+    updated_at: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    type: "cloudflare" | "huawei";
+    config: Prisma.JsonValue;
+}, {
+    name: string;
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    type: "cloudflare" | "huawei";
+    config: Prisma.JsonValue;
+}>;
+export type DNSProvider = z.infer<typeof DNSProviderSchema>;
+export declare const NodeGroupIncludeSchema: z.ZodType<Prisma.NodeGroupInclude>;
+export declare const NodeGroupArgsSchema: z.ZodType<Prisma.NodeGroupDefaultArgs>;
+export declare const NodeGroupCountOutputTypeArgsSchema: z.ZodType<Prisma.NodeGroupCountOutputTypeDefaultArgs>;
+export declare const NodeGroupCountOutputTypeSelectSchema: z.ZodType<Prisma.NodeGroupCountOutputTypeSelect>;
+export declare const NodeGroupSelectSchema: z.ZodType<Prisma.NodeGroupSelect>;
+export declare const NodeIncludeSchema: z.ZodType<Prisma.NodeInclude>;
+export declare const NodeArgsSchema: z.ZodType<Prisma.NodeDefaultArgs>;
+export declare const NodeSelectSchema: z.ZodType<Prisma.NodeSelect>;
+export declare const TunnelIncludeSchema: z.ZodType<Prisma.TunnelInclude>;
+export declare const TunnelArgsSchema: z.ZodType<Prisma.TunnelDefaultArgs>;
+export declare const TunnelCountOutputTypeArgsSchema: z.ZodType<Prisma.TunnelCountOutputTypeDefaultArgs>;
+export declare const TunnelCountOutputTypeSelectSchema: z.ZodType<Prisma.TunnelCountOutputTypeSelect>;
+export declare const TunnelSelectSchema: z.ZodType<Prisma.TunnelSelect>;
+export declare const TunnelChainIncludeSchema: z.ZodType<Prisma.TunnelChainInclude>;
+export declare const TunnelChainArgsSchema: z.ZodType<Prisma.TunnelChainDefaultArgs>;
+export declare const TunnelChainSelectSchema: z.ZodType<Prisma.TunnelChainSelect>;
+export declare const UserIncludeSchema: z.ZodType<Prisma.UserInclude>;
+export declare const UserArgsSchema: z.ZodType<Prisma.UserDefaultArgs>;
+export declare const UserCountOutputTypeArgsSchema: z.ZodType<Prisma.UserCountOutputTypeDefaultArgs>;
+export declare const UserCountOutputTypeSelectSchema: z.ZodType<Prisma.UserCountOutputTypeSelect>;
+export declare const UserSelectSchema: z.ZodType<Prisma.UserSelect>;
+export declare const UserPlanIncludeSchema: z.ZodType<Prisma.UserPlanInclude>;
+export declare const UserPlanArgsSchema: z.ZodType<Prisma.UserPlanDefaultArgs>;
+export declare const UserPlanSelectSchema: z.ZodType<Prisma.UserPlanSelect>;
+export declare const PlanIncludeSchema: z.ZodType<Prisma.PlanInclude>;
+export declare const PlanArgsSchema: z.ZodType<Prisma.PlanDefaultArgs>;
+export declare const PlanCountOutputTypeArgsSchema: z.ZodType<Prisma.PlanCountOutputTypeDefaultArgs>;
+export declare const PlanCountOutputTypeSelectSchema: z.ZodType<Prisma.PlanCountOutputTypeSelect>;
+export declare const PlanSelectSchema: z.ZodType<Prisma.PlanSelect>;
+export declare const PlanNodeGroupIncludeSchema: z.ZodType<Prisma.PlanNodeGroupInclude>;
+export declare const PlanNodeGroupArgsSchema: z.ZodType<Prisma.PlanNodeGroupDefaultArgs>;
+export declare const PlanNodeGroupSelectSchema: z.ZodType<Prisma.PlanNodeGroupSelect>;
+export declare const PlanOrderIncludeSchema: z.ZodType<Prisma.PlanOrderInclude>;
+export declare const PlanOrderArgsSchema: z.ZodType<Prisma.PlanOrderDefaultArgs>;
+export declare const PlanOrderSelectSchema: z.ZodType<Prisma.PlanOrderSelect>;
+export declare const TopupOrderIncludeSchema: z.ZodType<Prisma.TopupOrderInclude>;
+export declare const TopupOrderArgsSchema: z.ZodType<Prisma.TopupOrderDefaultArgs>;
+export declare const TopupOrderSelectSchema: z.ZodType<Prisma.TopupOrderSelect>;
+export declare const TopupActivitySelectSchema: z.ZodType<Prisma.TopupActivitySelect>;
+export declare const TunnelTrafficIncludeSchema: z.ZodType<Prisma.TunnelTrafficInclude>;
+export declare const TunnelTrafficArgsSchema: z.ZodType<Prisma.TunnelTrafficDefaultArgs>;
+export declare const TunnelTrafficSelectSchema: z.ZodType<Prisma.TunnelTrafficSelect>;
+export declare const SystemConfigSelectSchema: z.ZodType<Prisma.SystemConfigSelect>;
+export declare const PaymentIncludeSchema: z.ZodType<Prisma.PaymentInclude>;
+export declare const PaymentArgsSchema: z.ZodType<Prisma.PaymentDefaultArgs>;
+export declare const PaymentCountOutputTypeArgsSchema: z.ZodType<Prisma.PaymentCountOutputTypeDefaultArgs>;
+export declare const PaymentCountOutputTypeSelectSchema: z.ZodType<Prisma.PaymentCountOutputTypeSelect>;
+export declare const PaymentSelectSchema: z.ZodType<Prisma.PaymentSelect>;
+export declare const PlanCouponIncludeSchema: z.ZodType<Prisma.PlanCouponInclude>;
+export declare const PlanCouponArgsSchema: z.ZodType<Prisma.PlanCouponDefaultArgs>;
+export declare const PlanCouponCountOutputTypeArgsSchema: z.ZodType<Prisma.PlanCouponCountOutputTypeDefaultArgs>;
+export declare const PlanCouponCountOutputTypeSelectSchema: z.ZodType<Prisma.PlanCouponCountOutputTypeSelect>;
+export declare const PlanCouponSelectSchema: z.ZodType<Prisma.PlanCouponSelect>;
+export declare const BalanceLogIncludeSchema: z.ZodType<Prisma.BalanceLogInclude>;
+export declare const BalanceLogArgsSchema: z.ZodType<Prisma.BalanceLogDefaultArgs>;
+export declare const BalanceLogSelectSchema: z.ZodType<Prisma.BalanceLogSelect>;
+export declare const TicketIncludeSchema: z.ZodType<Prisma.TicketInclude>;
+export declare const TicketArgsSchema: z.ZodType<Prisma.TicketDefaultArgs>;
+export declare const TicketCountOutputTypeArgsSchema: z.ZodType<Prisma.TicketCountOutputTypeDefaultArgs>;
+export declare const TicketCountOutputTypeSelectSchema: z.ZodType<Prisma.TicketCountOutputTypeSelect>;
+export declare const TicketSelectSchema: z.ZodType<Prisma.TicketSelect>;
+export declare const TicketReplyIncludeSchema: z.ZodType<Prisma.TicketReplyInclude>;
+export declare const TicketReplyArgsSchema: z.ZodType<Prisma.TicketReplyDefaultArgs>;
+export declare const TicketReplySelectSchema: z.ZodType<Prisma.TicketReplySelect>;
+export declare const InNodeGroupDNSIncludeSchema: z.ZodType<Prisma.InNodeGroupDNSInclude>;
+export declare const InNodeGroupDNSArgsSchema: z.ZodType<Prisma.InNodeGroupDNSDefaultArgs>;
+export declare const InNodeGroupDNSSelectSchema: z.ZodType<Prisma.InNodeGroupDNSSelect>;
+export declare const DNSProviderIncludeSchema: z.ZodType<Prisma.DNSProviderInclude>;
+export declare const DNSProviderArgsSchema: z.ZodType<Prisma.DNSProviderDefaultArgs>;
+export declare const DNSProviderCountOutputTypeArgsSchema: z.ZodType<Prisma.DNSProviderCountOutputTypeDefaultArgs>;
+export declare const DNSProviderCountOutputTypeSelectSchema: z.ZodType<Prisma.DNSProviderCountOutputTypeSelect>;
+export declare const DNSProviderSelectSchema: z.ZodType<Prisma.DNSProviderSelect>;
+export declare const NodeGroupWhereInputSchema: z.ZodType<Prisma.NodeGroupWhereInput>;
+export declare const NodeGroupOrderByWithRelationInputSchema: z.ZodType<Prisma.NodeGroupOrderByWithRelationInput>;
+export declare const NodeGroupWhereUniqueInputSchema: z.ZodType<Prisma.NodeGroupWhereUniqueInput>;
+export declare const NodeGroupOrderByWithAggregationInputSchema: z.ZodType<Prisma.NodeGroupOrderByWithAggregationInput>;
+export declare const NodeGroupScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.NodeGroupScalarWhereWithAggregatesInput>;
+export declare const NodeWhereInputSchema: z.ZodType<Prisma.NodeWhereInput>;
+export declare const NodeOrderByWithRelationInputSchema: z.ZodType<Prisma.NodeOrderByWithRelationInput>;
+export declare const NodeWhereUniqueInputSchema: z.ZodType<Prisma.NodeWhereUniqueInput>;
+export declare const NodeOrderByWithAggregationInputSchema: z.ZodType<Prisma.NodeOrderByWithAggregationInput>;
+export declare const NodeScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.NodeScalarWhereWithAggregatesInput>;
+export declare const TunnelWhereInputSchema: z.ZodType<Prisma.TunnelWhereInput>;
+export declare const TunnelOrderByWithRelationInputSchema: z.ZodType<Prisma.TunnelOrderByWithRelationInput>;
+export declare const TunnelWhereUniqueInputSchema: z.ZodType<Prisma.TunnelWhereUniqueInput>;
+export declare const TunnelOrderByWithAggregationInputSchema: z.ZodType<Prisma.TunnelOrderByWithAggregationInput>;
+export declare const TunnelScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.TunnelScalarWhereWithAggregatesInput>;
+export declare const TunnelChainWhereInputSchema: z.ZodType<Prisma.TunnelChainWhereInput>;
+export declare const TunnelChainOrderByWithRelationInputSchema: z.ZodType<Prisma.TunnelChainOrderByWithRelationInput>;
+export declare const TunnelChainWhereUniqueInputSchema: z.ZodType<Prisma.TunnelChainWhereUniqueInput>;
+export declare const TunnelChainOrderByWithAggregationInputSchema: z.ZodType<Prisma.TunnelChainOrderByWithAggregationInput>;
+export declare const TunnelChainScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.TunnelChainScalarWhereWithAggregatesInput>;
+export declare const UserWhereInputSchema: z.ZodType<Prisma.UserWhereInput>;
+export declare const UserOrderByWithRelationInputSchema: z.ZodType<Prisma.UserOrderByWithRelationInput>;
+export declare const UserWhereUniqueInputSchema: z.ZodType<Prisma.UserWhereUniqueInput>;
+export declare const UserOrderByWithAggregationInputSchema: z.ZodType<Prisma.UserOrderByWithAggregationInput>;
+export declare const UserScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.UserScalarWhereWithAggregatesInput>;
+export declare const UserPlanWhereInputSchema: z.ZodType<Prisma.UserPlanWhereInput>;
+export declare const UserPlanOrderByWithRelationInputSchema: z.ZodType<Prisma.UserPlanOrderByWithRelationInput>;
+export declare const UserPlanWhereUniqueInputSchema: z.ZodType<Prisma.UserPlanWhereUniqueInput>;
+export declare const UserPlanOrderByWithAggregationInputSchema: z.ZodType<Prisma.UserPlanOrderByWithAggregationInput>;
+export declare const UserPlanScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.UserPlanScalarWhereWithAggregatesInput>;
+export declare const PlanWhereInputSchema: z.ZodType<Prisma.PlanWhereInput>;
+export declare const PlanOrderByWithRelationInputSchema: z.ZodType<Prisma.PlanOrderByWithRelationInput>;
+export declare const PlanWhereUniqueInputSchema: z.ZodType<Prisma.PlanWhereUniqueInput>;
+export declare const PlanOrderByWithAggregationInputSchema: z.ZodType<Prisma.PlanOrderByWithAggregationInput>;
+export declare const PlanScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.PlanScalarWhereWithAggregatesInput>;
+export declare const PlanNodeGroupWhereInputSchema: z.ZodType<Prisma.PlanNodeGroupWhereInput>;
+export declare const PlanNodeGroupOrderByWithRelationInputSchema: z.ZodType<Prisma.PlanNodeGroupOrderByWithRelationInput>;
+export declare const PlanNodeGroupWhereUniqueInputSchema: z.ZodType<Prisma.PlanNodeGroupWhereUniqueInput>;
+export declare const PlanNodeGroupOrderByWithAggregationInputSchema: z.ZodType<Prisma.PlanNodeGroupOrderByWithAggregationInput>;
+export declare const PlanNodeGroupScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.PlanNodeGroupScalarWhereWithAggregatesInput>;
+export declare const PlanOrderWhereInputSchema: z.ZodType<Prisma.PlanOrderWhereInput>;
+export declare const PlanOrderOrderByWithRelationInputSchema: z.ZodType<Prisma.PlanOrderOrderByWithRelationInput>;
+export declare const PlanOrderWhereUniqueInputSchema: z.ZodType<Prisma.PlanOrderWhereUniqueInput>;
+export declare const PlanOrderOrderByWithAggregationInputSchema: z.ZodType<Prisma.PlanOrderOrderByWithAggregationInput>;
+export declare const PlanOrderScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.PlanOrderScalarWhereWithAggregatesInput>;
+export declare const TopupOrderWhereInputSchema: z.ZodType<Prisma.TopupOrderWhereInput>;
+export declare const TopupOrderOrderByWithRelationInputSchema: z.ZodType<Prisma.TopupOrderOrderByWithRelationInput>;
+export declare const TopupOrderWhereUniqueInputSchema: z.ZodType<Prisma.TopupOrderWhereUniqueInput>;
+export declare const TopupOrderOrderByWithAggregationInputSchema: z.ZodType<Prisma.TopupOrderOrderByWithAggregationInput>;
+export declare const TopupOrderScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.TopupOrderScalarWhereWithAggregatesInput>;
+export declare const TopupActivityWhereInputSchema: z.ZodType<Prisma.TopupActivityWhereInput>;
+export declare const TopupActivityOrderByWithRelationInputSchema: z.ZodType<Prisma.TopupActivityOrderByWithRelationInput>;
+export declare const TopupActivityWhereUniqueInputSchema: z.ZodType<Prisma.TopupActivityWhereUniqueInput>;
+export declare const TopupActivityOrderByWithAggregationInputSchema: z.ZodType<Prisma.TopupActivityOrderByWithAggregationInput>;
+export declare const TopupActivityScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.TopupActivityScalarWhereWithAggregatesInput>;
+export declare const TunnelTrafficWhereInputSchema: z.ZodType<Prisma.TunnelTrafficWhereInput>;
+export declare const TunnelTrafficOrderByWithRelationInputSchema: z.ZodType<Prisma.TunnelTrafficOrderByWithRelationInput>;
+export declare const TunnelTrafficWhereUniqueInputSchema: z.ZodType<Prisma.TunnelTrafficWhereUniqueInput>;
+export declare const TunnelTrafficOrderByWithAggregationInputSchema: z.ZodType<Prisma.TunnelTrafficOrderByWithAggregationInput>;
+export declare const TunnelTrafficScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.TunnelTrafficScalarWhereWithAggregatesInput>;
+export declare const SystemConfigWhereInputSchema: z.ZodType<Prisma.SystemConfigWhereInput>;
+export declare const SystemConfigOrderByWithRelationInputSchema: z.ZodType<Prisma.SystemConfigOrderByWithRelationInput>;
+export declare const SystemConfigWhereUniqueInputSchema: z.ZodType<Prisma.SystemConfigWhereUniqueInput>;
+export declare const SystemConfigOrderByWithAggregationInputSchema: z.ZodType<Prisma.SystemConfigOrderByWithAggregationInput>;
+export declare const SystemConfigScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.SystemConfigScalarWhereWithAggregatesInput>;
+export declare const PaymentWhereInputSchema: z.ZodType<Prisma.PaymentWhereInput>;
+export declare const PaymentOrderByWithRelationInputSchema: z.ZodType<Prisma.PaymentOrderByWithRelationInput>;
+export declare const PaymentWhereUniqueInputSchema: z.ZodType<Prisma.PaymentWhereUniqueInput>;
+export declare const PaymentOrderByWithAggregationInputSchema: z.ZodType<Prisma.PaymentOrderByWithAggregationInput>;
+export declare const PaymentScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.PaymentScalarWhereWithAggregatesInput>;
+export declare const PlanCouponWhereInputSchema: z.ZodType<Prisma.PlanCouponWhereInput>;
+export declare const PlanCouponOrderByWithRelationInputSchema: z.ZodType<Prisma.PlanCouponOrderByWithRelationInput>;
+export declare const PlanCouponWhereUniqueInputSchema: z.ZodType<Prisma.PlanCouponWhereUniqueInput>;
+export declare const PlanCouponOrderByWithAggregationInputSchema: z.ZodType<Prisma.PlanCouponOrderByWithAggregationInput>;
+export declare const PlanCouponScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.PlanCouponScalarWhereWithAggregatesInput>;
+export declare const BalanceLogWhereInputSchema: z.ZodType<Prisma.BalanceLogWhereInput>;
+export declare const BalanceLogOrderByWithRelationInputSchema: z.ZodType<Prisma.BalanceLogOrderByWithRelationInput>;
+export declare const BalanceLogWhereUniqueInputSchema: z.ZodType<Prisma.BalanceLogWhereUniqueInput>;
+export declare const BalanceLogOrderByWithAggregationInputSchema: z.ZodType<Prisma.BalanceLogOrderByWithAggregationInput>;
+export declare const BalanceLogScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.BalanceLogScalarWhereWithAggregatesInput>;
+export declare const TicketWhereInputSchema: z.ZodType<Prisma.TicketWhereInput>;
+export declare const TicketOrderByWithRelationInputSchema: z.ZodType<Prisma.TicketOrderByWithRelationInput>;
+export declare const TicketWhereUniqueInputSchema: z.ZodType<Prisma.TicketWhereUniqueInput>;
+export declare const TicketOrderByWithAggregationInputSchema: z.ZodType<Prisma.TicketOrderByWithAggregationInput>;
+export declare const TicketScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.TicketScalarWhereWithAggregatesInput>;
+export declare const TicketReplyWhereInputSchema: z.ZodType<Prisma.TicketReplyWhereInput>;
+export declare const TicketReplyOrderByWithRelationInputSchema: z.ZodType<Prisma.TicketReplyOrderByWithRelationInput>;
+export declare const TicketReplyWhereUniqueInputSchema: z.ZodType<Prisma.TicketReplyWhereUniqueInput>;
+export declare const TicketReplyOrderByWithAggregationInputSchema: z.ZodType<Prisma.TicketReplyOrderByWithAggregationInput>;
+export declare const TicketReplyScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.TicketReplyScalarWhereWithAggregatesInput>;
+export declare const InNodeGroupDNSWhereInputSchema: z.ZodType<Prisma.InNodeGroupDNSWhereInput>;
+export declare const InNodeGroupDNSOrderByWithRelationInputSchema: z.ZodType<Prisma.InNodeGroupDNSOrderByWithRelationInput>;
+export declare const InNodeGroupDNSWhereUniqueInputSchema: z.ZodType<Prisma.InNodeGroupDNSWhereUniqueInput>;
+export declare const InNodeGroupDNSOrderByWithAggregationInputSchema: z.ZodType<Prisma.InNodeGroupDNSOrderByWithAggregationInput>;
+export declare const InNodeGroupDNSScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.InNodeGroupDNSScalarWhereWithAggregatesInput>;
+export declare const DNSProviderWhereInputSchema: z.ZodType<Prisma.DNSProviderWhereInput>;
+export declare const DNSProviderOrderByWithRelationInputSchema: z.ZodType<Prisma.DNSProviderOrderByWithRelationInput>;
+export declare const DNSProviderWhereUniqueInputSchema: z.ZodType<Prisma.DNSProviderWhereUniqueInput>;
+export declare const DNSProviderOrderByWithAggregationInputSchema: z.ZodType<Prisma.DNSProviderOrderByWithAggregationInput>;
+export declare const DNSProviderScalarWhereWithAggregatesInputSchema: z.ZodType<Prisma.DNSProviderScalarWhereWithAggregatesInput>;
+export declare const NodeGroupCreateInputSchema: z.ZodType<Prisma.NodeGroupCreateInput>;
+export declare const NodeGroupUncheckedCreateInputSchema: z.ZodType<Prisma.NodeGroupUncheckedCreateInput>;
+export declare const NodeGroupUpdateInputSchema: z.ZodType<Prisma.NodeGroupUpdateInput>;
+export declare const NodeGroupUncheckedUpdateInputSchema: z.ZodType<Prisma.NodeGroupUncheckedUpdateInput>;
+export declare const NodeGroupCreateManyInputSchema: z.ZodType<Prisma.NodeGroupCreateManyInput>;
+export declare const NodeGroupUpdateManyMutationInputSchema: z.ZodType<Prisma.NodeGroupUpdateManyMutationInput>;
+export declare const NodeGroupUncheckedUpdateManyInputSchema: z.ZodType<Prisma.NodeGroupUncheckedUpdateManyInput>;
+export declare const NodeCreateInputSchema: z.ZodType<Prisma.NodeCreateInput>;
+export declare const NodeUncheckedCreateInputSchema: z.ZodType<Prisma.NodeUncheckedCreateInput>;
+export declare const NodeUpdateInputSchema: z.ZodType<Prisma.NodeUpdateInput>;
+export declare const NodeUncheckedUpdateInputSchema: z.ZodType<Prisma.NodeUncheckedUpdateInput>;
+export declare const NodeCreateManyInputSchema: z.ZodType<Prisma.NodeCreateManyInput>;
+export declare const NodeUpdateManyMutationInputSchema: z.ZodType<Prisma.NodeUpdateManyMutationInput>;
+export declare const NodeUncheckedUpdateManyInputSchema: z.ZodType<Prisma.NodeUncheckedUpdateManyInput>;
+export declare const TunnelCreateInputSchema: z.ZodType<Prisma.TunnelCreateInput>;
+export declare const TunnelUncheckedCreateInputSchema: z.ZodType<Prisma.TunnelUncheckedCreateInput>;
+export declare const TunnelUpdateInputSchema: z.ZodType<Prisma.TunnelUpdateInput>;
+export declare const TunnelUncheckedUpdateInputSchema: z.ZodType<Prisma.TunnelUncheckedUpdateInput>;
+export declare const TunnelCreateManyInputSchema: z.ZodType<Prisma.TunnelCreateManyInput>;
+export declare const TunnelUpdateManyMutationInputSchema: z.ZodType<Prisma.TunnelUpdateManyMutationInput>;
+export declare const TunnelUncheckedUpdateManyInputSchema: z.ZodType<Prisma.TunnelUncheckedUpdateManyInput>;
+export declare const TunnelChainCreateInputSchema: z.ZodType<Prisma.TunnelChainCreateInput>;
+export declare const TunnelChainUncheckedCreateInputSchema: z.ZodType<Prisma.TunnelChainUncheckedCreateInput>;
+export declare const TunnelChainUpdateInputSchema: z.ZodType<Prisma.TunnelChainUpdateInput>;
+export declare const TunnelChainUncheckedUpdateInputSchema: z.ZodType<Prisma.TunnelChainUncheckedUpdateInput>;
+export declare const TunnelChainCreateManyInputSchema: z.ZodType<Prisma.TunnelChainCreateManyInput>;
+export declare const TunnelChainUpdateManyMutationInputSchema: z.ZodType<Prisma.TunnelChainUpdateManyMutationInput>;
+export declare const TunnelChainUncheckedUpdateManyInputSchema: z.ZodType<Prisma.TunnelChainUncheckedUpdateManyInput>;
+export declare const UserCreateInputSchema: z.ZodType<Prisma.UserCreateInput>;
+export declare const UserUncheckedCreateInputSchema: z.ZodType<Prisma.UserUncheckedCreateInput>;
+export declare const UserUpdateInputSchema: z.ZodType<Prisma.UserUpdateInput>;
+export declare const UserUncheckedUpdateInputSchema: z.ZodType<Prisma.UserUncheckedUpdateInput>;
+export declare const UserCreateManyInputSchema: z.ZodType<Prisma.UserCreateManyInput>;
+export declare const UserUpdateManyMutationInputSchema: z.ZodType<Prisma.UserUpdateManyMutationInput>;
+export declare const UserUncheckedUpdateManyInputSchema: z.ZodType<Prisma.UserUncheckedUpdateManyInput>;
+export declare const UserPlanCreateInputSchema: z.ZodType<Prisma.UserPlanCreateInput>;
+export declare const UserPlanUncheckedCreateInputSchema: z.ZodType<Prisma.UserPlanUncheckedCreateInput>;
+export declare const UserPlanUpdateInputSchema: z.ZodType<Prisma.UserPlanUpdateInput>;
+export declare const UserPlanUncheckedUpdateInputSchema: z.ZodType<Prisma.UserPlanUncheckedUpdateInput>;
+export declare const UserPlanCreateManyInputSchema: z.ZodType<Prisma.UserPlanCreateManyInput>;
+export declare const UserPlanUpdateManyMutationInputSchema: z.ZodType<Prisma.UserPlanUpdateManyMutationInput>;
+export declare const UserPlanUncheckedUpdateManyInputSchema: z.ZodType<Prisma.UserPlanUncheckedUpdateManyInput>;
+export declare const PlanCreateInputSchema: z.ZodType<Prisma.PlanCreateInput>;
+export declare const PlanUncheckedCreateInputSchema: z.ZodType<Prisma.PlanUncheckedCreateInput>;
+export declare const PlanUpdateInputSchema: z.ZodType<Prisma.PlanUpdateInput>;
+export declare const PlanUncheckedUpdateInputSchema: z.ZodType<Prisma.PlanUncheckedUpdateInput>;
+export declare const PlanCreateManyInputSchema: z.ZodType<Prisma.PlanCreateManyInput>;
+export declare const PlanUpdateManyMutationInputSchema: z.ZodType<Prisma.PlanUpdateManyMutationInput>;
+export declare const PlanUncheckedUpdateManyInputSchema: z.ZodType<Prisma.PlanUncheckedUpdateManyInput>;
+export declare const PlanNodeGroupCreateInputSchema: z.ZodType<Prisma.PlanNodeGroupCreateInput>;
+export declare const PlanNodeGroupUncheckedCreateInputSchema: z.ZodType<Prisma.PlanNodeGroupUncheckedCreateInput>;
+export declare const PlanNodeGroupUpdateInputSchema: z.ZodType<Prisma.PlanNodeGroupUpdateInput>;
+export declare const PlanNodeGroupUncheckedUpdateInputSchema: z.ZodType<Prisma.PlanNodeGroupUncheckedUpdateInput>;
+export declare const PlanNodeGroupCreateManyInputSchema: z.ZodType<Prisma.PlanNodeGroupCreateManyInput>;
+export declare const PlanNodeGroupUpdateManyMutationInputSchema: z.ZodType<Prisma.PlanNodeGroupUpdateManyMutationInput>;
+export declare const PlanNodeGroupUncheckedUpdateManyInputSchema: z.ZodType<Prisma.PlanNodeGroupUncheckedUpdateManyInput>;
+export declare const PlanOrderCreateInputSchema: z.ZodType<Prisma.PlanOrderCreateInput>;
+export declare const PlanOrderUncheckedCreateInputSchema: z.ZodType<Prisma.PlanOrderUncheckedCreateInput>;
+export declare const PlanOrderUpdateInputSchema: z.ZodType<Prisma.PlanOrderUpdateInput>;
+export declare const PlanOrderUncheckedUpdateInputSchema: z.ZodType<Prisma.PlanOrderUncheckedUpdateInput>;
+export declare const PlanOrderCreateManyInputSchema: z.ZodType<Prisma.PlanOrderCreateManyInput>;
+export declare const PlanOrderUpdateManyMutationInputSchema: z.ZodType<Prisma.PlanOrderUpdateManyMutationInput>;
+export declare const PlanOrderUncheckedUpdateManyInputSchema: z.ZodType<Prisma.PlanOrderUncheckedUpdateManyInput>;
+export declare const TopupOrderCreateInputSchema: z.ZodType<Prisma.TopupOrderCreateInput>;
+export declare const TopupOrderUncheckedCreateInputSchema: z.ZodType<Prisma.TopupOrderUncheckedCreateInput>;
+export declare const TopupOrderUpdateInputSchema: z.ZodType<Prisma.TopupOrderUpdateInput>;
+export declare const TopupOrderUncheckedUpdateInputSchema: z.ZodType<Prisma.TopupOrderUncheckedUpdateInput>;
+export declare const TopupOrderCreateManyInputSchema: z.ZodType<Prisma.TopupOrderCreateManyInput>;
+export declare const TopupOrderUpdateManyMutationInputSchema: z.ZodType<Prisma.TopupOrderUpdateManyMutationInput>;
+export declare const TopupOrderUncheckedUpdateManyInputSchema: z.ZodType<Prisma.TopupOrderUncheckedUpdateManyInput>;
+export declare const TopupActivityCreateInputSchema: z.ZodType<Prisma.TopupActivityCreateInput>;
+export declare const TopupActivityUncheckedCreateInputSchema: z.ZodType<Prisma.TopupActivityUncheckedCreateInput>;
+export declare const TopupActivityUpdateInputSchema: z.ZodType<Prisma.TopupActivityUpdateInput>;
+export declare const TopupActivityUncheckedUpdateInputSchema: z.ZodType<Prisma.TopupActivityUncheckedUpdateInput>;
+export declare const TopupActivityCreateManyInputSchema: z.ZodType<Prisma.TopupActivityCreateManyInput>;
+export declare const TopupActivityUpdateManyMutationInputSchema: z.ZodType<Prisma.TopupActivityUpdateManyMutationInput>;
+export declare const TopupActivityUncheckedUpdateManyInputSchema: z.ZodType<Prisma.TopupActivityUncheckedUpdateManyInput>;
+export declare const TunnelTrafficCreateInputSchema: z.ZodType<Prisma.TunnelTrafficCreateInput>;
+export declare const TunnelTrafficUncheckedCreateInputSchema: z.ZodType<Prisma.TunnelTrafficUncheckedCreateInput>;
+export declare const TunnelTrafficUpdateInputSchema: z.ZodType<Prisma.TunnelTrafficUpdateInput>;
+export declare const TunnelTrafficUncheckedUpdateInputSchema: z.ZodType<Prisma.TunnelTrafficUncheckedUpdateInput>;
+export declare const TunnelTrafficCreateManyInputSchema: z.ZodType<Prisma.TunnelTrafficCreateManyInput>;
+export declare const TunnelTrafficUpdateManyMutationInputSchema: z.ZodType<Prisma.TunnelTrafficUpdateManyMutationInput>;
+export declare const TunnelTrafficUncheckedUpdateManyInputSchema: z.ZodType<Prisma.TunnelTrafficUncheckedUpdateManyInput>;
+export declare const SystemConfigCreateInputSchema: z.ZodType<Prisma.SystemConfigCreateInput>;
+export declare const SystemConfigUncheckedCreateInputSchema: z.ZodType<Prisma.SystemConfigUncheckedCreateInput>;
+export declare const SystemConfigUpdateInputSchema: z.ZodType<Prisma.SystemConfigUpdateInput>;
+export declare const SystemConfigUncheckedUpdateInputSchema: z.ZodType<Prisma.SystemConfigUncheckedUpdateInput>;
+export declare const SystemConfigCreateManyInputSchema: z.ZodType<Prisma.SystemConfigCreateManyInput>;
+export declare const SystemConfigUpdateManyMutationInputSchema: z.ZodType<Prisma.SystemConfigUpdateManyMutationInput>;
+export declare const SystemConfigUncheckedUpdateManyInputSchema: z.ZodType<Prisma.SystemConfigUncheckedUpdateManyInput>;
+export declare const PaymentCreateInputSchema: z.ZodType<Prisma.PaymentCreateInput>;
+export declare const PaymentUncheckedCreateInputSchema: z.ZodType<Prisma.PaymentUncheckedCreateInput>;
+export declare const PaymentUpdateInputSchema: z.ZodType<Prisma.PaymentUpdateInput>;
+export declare const PaymentUncheckedUpdateInputSchema: z.ZodType<Prisma.PaymentUncheckedUpdateInput>;
+export declare const PaymentCreateManyInputSchema: z.ZodType<Prisma.PaymentCreateManyInput>;
+export declare const PaymentUpdateManyMutationInputSchema: z.ZodType<Prisma.PaymentUpdateManyMutationInput>;
+export declare const PaymentUncheckedUpdateManyInputSchema: z.ZodType<Prisma.PaymentUncheckedUpdateManyInput>;
+export declare const PlanCouponCreateInputSchema: z.ZodType<Prisma.PlanCouponCreateInput>;
+export declare const PlanCouponUncheckedCreateInputSchema: z.ZodType<Prisma.PlanCouponUncheckedCreateInput>;
+export declare const PlanCouponUpdateInputSchema: z.ZodType<Prisma.PlanCouponUpdateInput>;
+export declare const PlanCouponUncheckedUpdateInputSchema: z.ZodType<Prisma.PlanCouponUncheckedUpdateInput>;
+export declare const PlanCouponCreateManyInputSchema: z.ZodType<Prisma.PlanCouponCreateManyInput>;
+export declare const PlanCouponUpdateManyMutationInputSchema: z.ZodType<Prisma.PlanCouponUpdateManyMutationInput>;
+export declare const PlanCouponUncheckedUpdateManyInputSchema: z.ZodType<Prisma.PlanCouponUncheckedUpdateManyInput>;
+export declare const BalanceLogCreateInputSchema: z.ZodType<Prisma.BalanceLogCreateInput>;
+export declare const BalanceLogUncheckedCreateInputSchema: z.ZodType<Prisma.BalanceLogUncheckedCreateInput>;
+export declare const BalanceLogUpdateInputSchema: z.ZodType<Prisma.BalanceLogUpdateInput>;
+export declare const BalanceLogUncheckedUpdateInputSchema: z.ZodType<Prisma.BalanceLogUncheckedUpdateInput>;
+export declare const BalanceLogCreateManyInputSchema: z.ZodType<Prisma.BalanceLogCreateManyInput>;
+export declare const BalanceLogUpdateManyMutationInputSchema: z.ZodType<Prisma.BalanceLogUpdateManyMutationInput>;
+export declare const BalanceLogUncheckedUpdateManyInputSchema: z.ZodType<Prisma.BalanceLogUncheckedUpdateManyInput>;
+export declare const TicketCreateInputSchema: z.ZodType<Prisma.TicketCreateInput>;
+export declare const TicketUncheckedCreateInputSchema: z.ZodType<Prisma.TicketUncheckedCreateInput>;
+export declare const TicketUpdateInputSchema: z.ZodType<Prisma.TicketUpdateInput>;
+export declare const TicketUncheckedUpdateInputSchema: z.ZodType<Prisma.TicketUncheckedUpdateInput>;
+export declare const TicketCreateManyInputSchema: z.ZodType<Prisma.TicketCreateManyInput>;
+export declare const TicketUpdateManyMutationInputSchema: z.ZodType<Prisma.TicketUpdateManyMutationInput>;
+export declare const TicketUncheckedUpdateManyInputSchema: z.ZodType<Prisma.TicketUncheckedUpdateManyInput>;
+export declare const TicketReplyCreateInputSchema: z.ZodType<Prisma.TicketReplyCreateInput>;
+export declare const TicketReplyUncheckedCreateInputSchema: z.ZodType<Prisma.TicketReplyUncheckedCreateInput>;
+export declare const TicketReplyUpdateInputSchema: z.ZodType<Prisma.TicketReplyUpdateInput>;
+export declare const TicketReplyUncheckedUpdateInputSchema: z.ZodType<Prisma.TicketReplyUncheckedUpdateInput>;
+export declare const TicketReplyCreateManyInputSchema: z.ZodType<Prisma.TicketReplyCreateManyInput>;
+export declare const TicketReplyUpdateManyMutationInputSchema: z.ZodType<Prisma.TicketReplyUpdateManyMutationInput>;
+export declare const TicketReplyUncheckedUpdateManyInputSchema: z.ZodType<Prisma.TicketReplyUncheckedUpdateManyInput>;
+export declare const InNodeGroupDNSCreateInputSchema: z.ZodType<Prisma.InNodeGroupDNSCreateInput>;
+export declare const InNodeGroupDNSUncheckedCreateInputSchema: z.ZodType<Prisma.InNodeGroupDNSUncheckedCreateInput>;
+export declare const InNodeGroupDNSUpdateInputSchema: z.ZodType<Prisma.InNodeGroupDNSUpdateInput>;
+export declare const InNodeGroupDNSUncheckedUpdateInputSchema: z.ZodType<Prisma.InNodeGroupDNSUncheckedUpdateInput>;
+export declare const InNodeGroupDNSCreateManyInputSchema: z.ZodType<Prisma.InNodeGroupDNSCreateManyInput>;
+export declare const InNodeGroupDNSUpdateManyMutationInputSchema: z.ZodType<Prisma.InNodeGroupDNSUpdateManyMutationInput>;
+export declare const InNodeGroupDNSUncheckedUpdateManyInputSchema: z.ZodType<Prisma.InNodeGroupDNSUncheckedUpdateManyInput>;
+export declare const DNSProviderCreateInputSchema: z.ZodType<Prisma.DNSProviderCreateInput>;
+export declare const DNSProviderUncheckedCreateInputSchema: z.ZodType<Prisma.DNSProviderUncheckedCreateInput>;
+export declare const DNSProviderUpdateInputSchema: z.ZodType<Prisma.DNSProviderUpdateInput>;
+export declare const DNSProviderUncheckedUpdateInputSchema: z.ZodType<Prisma.DNSProviderUncheckedUpdateInput>;
+export declare const DNSProviderCreateManyInputSchema: z.ZodType<Prisma.DNSProviderCreateManyInput>;
+export declare const DNSProviderUpdateManyMutationInputSchema: z.ZodType<Prisma.DNSProviderUpdateManyMutationInput>;
+export declare const DNSProviderUncheckedUpdateManyInputSchema: z.ZodType<Prisma.DNSProviderUncheckedUpdateManyInput>;
+export declare const IntFilterSchema: z.ZodType<Prisma.IntFilter>;
+export declare const StringFilterSchema: z.ZodType<Prisma.StringFilter>;
+export declare const StringNullableFilterSchema: z.ZodType<Prisma.StringNullableFilter>;
+export declare const EnumNodeTypeFilterSchema: z.ZodType<Prisma.EnumNodeTypeFilter>;
+export declare const EnumLoadBalanceTypeFilterSchema: z.ZodType<Prisma.EnumLoadBalanceTypeFilter>;
+export declare const BoolFilterSchema: z.ZodType<Prisma.BoolFilter>;
+export declare const JsonNullableFilterSchema: z.ZodType<Prisma.JsonNullableFilter>;
+export declare const EnumBypassTypeFilterSchema: z.ZodType<Prisma.EnumBypassTypeFilter>;
+export declare const FloatFilterSchema: z.ZodType<Prisma.FloatFilter>;
+export declare const DateTimeFilterSchema: z.ZodType<Prisma.DateTimeFilter>;
+export declare const UserScalarRelationFilterSchema: z.ZodType<Prisma.UserScalarRelationFilter>;
+export declare const TunnelListRelationFilterSchema: z.ZodType<Prisma.TunnelListRelationFilter>;
+export declare const NodeListRelationFilterSchema: z.ZodType<Prisma.NodeListRelationFilter>;
+export declare const PlanNodeGroupListRelationFilterSchema: z.ZodType<Prisma.PlanNodeGroupListRelationFilter>;
+export declare const TunnelChainListRelationFilterSchema: z.ZodType<Prisma.TunnelChainListRelationFilter>;
+export declare const InNodeGroupDNSListRelationFilterSchema: z.ZodType<Prisma.InNodeGroupDNSListRelationFilter>;
+export declare const SortOrderInputSchema: z.ZodType<Prisma.SortOrderInput>;
+export declare const TunnelOrderByRelationAggregateInputSchema: z.ZodType<Prisma.TunnelOrderByRelationAggregateInput>;
+export declare const NodeOrderByRelationAggregateInputSchema: z.ZodType<Prisma.NodeOrderByRelationAggregateInput>;
+export declare const PlanNodeGroupOrderByRelationAggregateInputSchema: z.ZodType<Prisma.PlanNodeGroupOrderByRelationAggregateInput>;
+export declare const TunnelChainOrderByRelationAggregateInputSchema: z.ZodType<Prisma.TunnelChainOrderByRelationAggregateInput>;
+export declare const InNodeGroupDNSOrderByRelationAggregateInputSchema: z.ZodType<Prisma.InNodeGroupDNSOrderByRelationAggregateInput>;
+export declare const NodeGroupOrderByRelevanceInputSchema: z.ZodType<Prisma.NodeGroupOrderByRelevanceInput>;
+export declare const NodeGroupCountOrderByAggregateInputSchema: z.ZodType<Prisma.NodeGroupCountOrderByAggregateInput>;
+export declare const NodeGroupAvgOrderByAggregateInputSchema: z.ZodType<Prisma.NodeGroupAvgOrderByAggregateInput>;
+export declare const NodeGroupMaxOrderByAggregateInputSchema: z.ZodType<Prisma.NodeGroupMaxOrderByAggregateInput>;
+export declare const NodeGroupMinOrderByAggregateInputSchema: z.ZodType<Prisma.NodeGroupMinOrderByAggregateInput>;
+export declare const NodeGroupSumOrderByAggregateInputSchema: z.ZodType<Prisma.NodeGroupSumOrderByAggregateInput>;
+export declare const IntWithAggregatesFilterSchema: z.ZodType<Prisma.IntWithAggregatesFilter>;
+export declare const StringWithAggregatesFilterSchema: z.ZodType<Prisma.StringWithAggregatesFilter>;
+export declare const StringNullableWithAggregatesFilterSchema: z.ZodType<Prisma.StringNullableWithAggregatesFilter>;
+export declare const EnumNodeTypeWithAggregatesFilterSchema: z.ZodType<Prisma.EnumNodeTypeWithAggregatesFilter>;
+export declare const EnumLoadBalanceTypeWithAggregatesFilterSchema: z.ZodType<Prisma.EnumLoadBalanceTypeWithAggregatesFilter>;
+export declare const BoolWithAggregatesFilterSchema: z.ZodType<Prisma.BoolWithAggregatesFilter>;
+export declare const JsonNullableWithAggregatesFilterSchema: z.ZodType<Prisma.JsonNullableWithAggregatesFilter>;
+export declare const EnumBypassTypeWithAggregatesFilterSchema: z.ZodType<Prisma.EnumBypassTypeWithAggregatesFilter>;
+export declare const FloatWithAggregatesFilterSchema: z.ZodType<Prisma.FloatWithAggregatesFilter>;
+export declare const DateTimeWithAggregatesFilterSchema: z.ZodType<Prisma.DateTimeWithAggregatesFilter>;
+export declare const EnumStatusFilterSchema: z.ZodType<Prisma.EnumStatusFilter>;
+export declare const NodeGroupScalarRelationFilterSchema: z.ZodType<Prisma.NodeGroupScalarRelationFilter>;
+export declare const NodeOrderByRelevanceInputSchema: z.ZodType<Prisma.NodeOrderByRelevanceInput>;
+export declare const NodeCountOrderByAggregateInputSchema: z.ZodType<Prisma.NodeCountOrderByAggregateInput>;
+export declare const NodeAvgOrderByAggregateInputSchema: z.ZodType<Prisma.NodeAvgOrderByAggregateInput>;
+export declare const NodeMaxOrderByAggregateInputSchema: z.ZodType<Prisma.NodeMaxOrderByAggregateInput>;
+export declare const NodeMinOrderByAggregateInputSchema: z.ZodType<Prisma.NodeMinOrderByAggregateInput>;
+export declare const NodeSumOrderByAggregateInputSchema: z.ZodType<Prisma.NodeSumOrderByAggregateInput>;
+export declare const EnumStatusWithAggregatesFilterSchema: z.ZodType<Prisma.EnumStatusWithAggregatesFilter>;
+export declare const EnumTunnelTypeFilterSchema: z.ZodType<Prisma.EnumTunnelTypeFilter>;
+export declare const EnumTunnelCategoryFilterSchema: z.ZodType<Prisma.EnumTunnelCategoryFilter>;
+export declare const IntNullableFilterSchema: z.ZodType<Prisma.IntNullableFilter>;
+export declare const JsonFilterSchema: z.ZodType<Prisma.JsonFilter>;
+export declare const EnumIpTypeFilterSchema: z.ZodType<Prisma.EnumIpTypeFilter>;
+export declare const NodeGroupNullableScalarRelationFilterSchema: z.ZodType<Prisma.NodeGroupNullableScalarRelationFilter>;
+export declare const TunnelTrafficListRelationFilterSchema: z.ZodType<Prisma.TunnelTrafficListRelationFilter>;
+export declare const TunnelTrafficOrderByRelationAggregateInputSchema: z.ZodType<Prisma.TunnelTrafficOrderByRelationAggregateInput>;
+export declare const TunnelOrderByRelevanceInputSchema: z.ZodType<Prisma.TunnelOrderByRelevanceInput>;
+export declare const TunnelListen_portIn_node_group_idCompoundUniqueInputSchema: z.ZodType<Prisma.TunnelListen_portIn_node_group_idCompoundUniqueInput>;
+export declare const TunnelCountOrderByAggregateInputSchema: z.ZodType<Prisma.TunnelCountOrderByAggregateInput>;
+export declare const TunnelAvgOrderByAggregateInputSchema: z.ZodType<Prisma.TunnelAvgOrderByAggregateInput>;
+export declare const TunnelMaxOrderByAggregateInputSchema: z.ZodType<Prisma.TunnelMaxOrderByAggregateInput>;
+export declare const TunnelMinOrderByAggregateInputSchema: z.ZodType<Prisma.TunnelMinOrderByAggregateInput>;
+export declare const TunnelSumOrderByAggregateInputSchema: z.ZodType<Prisma.TunnelSumOrderByAggregateInput>;
+export declare const EnumTunnelTypeWithAggregatesFilterSchema: z.ZodType<Prisma.EnumTunnelTypeWithAggregatesFilter>;
+export declare const EnumTunnelCategoryWithAggregatesFilterSchema: z.ZodType<Prisma.EnumTunnelCategoryWithAggregatesFilter>;
+export declare const IntNullableWithAggregatesFilterSchema: z.ZodType<Prisma.IntNullableWithAggregatesFilter>;
+export declare const JsonWithAggregatesFilterSchema: z.ZodType<Prisma.JsonWithAggregatesFilter>;
+export declare const EnumIpTypeWithAggregatesFilterSchema: z.ZodType<Prisma.EnumIpTypeWithAggregatesFilter>;
+export declare const TunnelScalarRelationFilterSchema: z.ZodType<Prisma.TunnelScalarRelationFilter>;
+export declare const TunnelChainCountOrderByAggregateInputSchema: z.ZodType<Prisma.TunnelChainCountOrderByAggregateInput>;
+export declare const TunnelChainAvgOrderByAggregateInputSchema: z.ZodType<Prisma.TunnelChainAvgOrderByAggregateInput>;
+export declare const TunnelChainMaxOrderByAggregateInputSchema: z.ZodType<Prisma.TunnelChainMaxOrderByAggregateInput>;
+export declare const TunnelChainMinOrderByAggregateInputSchema: z.ZodType<Prisma.TunnelChainMinOrderByAggregateInput>;
+export declare const TunnelChainSumOrderByAggregateInputSchema: z.ZodType<Prisma.TunnelChainSumOrderByAggregateInput>;
+export declare const FloatNullableFilterSchema: z.ZodType<Prisma.FloatNullableFilter>;
+export declare const BoolNullableFilterSchema: z.ZodType<Prisma.BoolNullableFilter>;
+export declare const UserNullableScalarRelationFilterSchema: z.ZodType<Prisma.UserNullableScalarRelationFilter>;
+export declare const UserListRelationFilterSchema: z.ZodType<Prisma.UserListRelationFilter>;
+export declare const NodeGroupListRelationFilterSchema: z.ZodType<Prisma.NodeGroupListRelationFilter>;
+export declare const PlanOrderListRelationFilterSchema: z.ZodType<Prisma.PlanOrderListRelationFilter>;
+export declare const TopupOrderListRelationFilterSchema: z.ZodType<Prisma.TopupOrderListRelationFilter>;
+export declare const UserPlanNullableScalarRelationFilterSchema: z.ZodType<Prisma.UserPlanNullableScalarRelationFilter>;
+export declare const BalanceLogListRelationFilterSchema: z.ZodType<Prisma.BalanceLogListRelationFilter>;
+export declare const TicketListRelationFilterSchema: z.ZodType<Prisma.TicketListRelationFilter>;
+export declare const TicketReplyListRelationFilterSchema: z.ZodType<Prisma.TicketReplyListRelationFilter>;
+export declare const UserOrderByRelationAggregateInputSchema: z.ZodType<Prisma.UserOrderByRelationAggregateInput>;
+export declare const NodeGroupOrderByRelationAggregateInputSchema: z.ZodType<Prisma.NodeGroupOrderByRelationAggregateInput>;
+export declare const PlanOrderOrderByRelationAggregateInputSchema: z.ZodType<Prisma.PlanOrderOrderByRelationAggregateInput>;
+export declare const TopupOrderOrderByRelationAggregateInputSchema: z.ZodType<Prisma.TopupOrderOrderByRelationAggregateInput>;
+export declare const BalanceLogOrderByRelationAggregateInputSchema: z.ZodType<Prisma.BalanceLogOrderByRelationAggregateInput>;
+export declare const TicketOrderByRelationAggregateInputSchema: z.ZodType<Prisma.TicketOrderByRelationAggregateInput>;
+export declare const TicketReplyOrderByRelationAggregateInputSchema: z.ZodType<Prisma.TicketReplyOrderByRelationAggregateInput>;
+export declare const UserOrderByRelevanceInputSchema: z.ZodType<Prisma.UserOrderByRelevanceInput>;
+export declare const UserCountOrderByAggregateInputSchema: z.ZodType<Prisma.UserCountOrderByAggregateInput>;
+export declare const UserAvgOrderByAggregateInputSchema: z.ZodType<Prisma.UserAvgOrderByAggregateInput>;
+export declare const UserMaxOrderByAggregateInputSchema: z.ZodType<Prisma.UserMaxOrderByAggregateInput>;
+export declare const UserMinOrderByAggregateInputSchema: z.ZodType<Prisma.UserMinOrderByAggregateInput>;
+export declare const UserSumOrderByAggregateInputSchema: z.ZodType<Prisma.UserSumOrderByAggregateInput>;
+export declare const FloatNullableWithAggregatesFilterSchema: z.ZodType<Prisma.FloatNullableWithAggregatesFilter>;
+export declare const BoolNullableWithAggregatesFilterSchema: z.ZodType<Prisma.BoolNullableWithAggregatesFilter>;
+export declare const DateTimeNullableFilterSchema: z.ZodType<Prisma.DateTimeNullableFilter>;
+export declare const PlanScalarRelationFilterSchema: z.ZodType<Prisma.PlanScalarRelationFilter>;
+export declare const UserPlanCountOrderByAggregateInputSchema: z.ZodType<Prisma.UserPlanCountOrderByAggregateInput>;
+export declare const UserPlanAvgOrderByAggregateInputSchema: z.ZodType<Prisma.UserPlanAvgOrderByAggregateInput>;
+export declare const UserPlanMaxOrderByAggregateInputSchema: z.ZodType<Prisma.UserPlanMaxOrderByAggregateInput>;
+export declare const UserPlanMinOrderByAggregateInputSchema: z.ZodType<Prisma.UserPlanMinOrderByAggregateInput>;
+export declare const UserPlanSumOrderByAggregateInputSchema: z.ZodType<Prisma.UserPlanSumOrderByAggregateInput>;
+export declare const DateTimeNullableWithAggregatesFilterSchema: z.ZodType<Prisma.DateTimeNullableWithAggregatesFilter>;
+export declare const EnumBillingCycleFilterSchema: z.ZodType<Prisma.EnumBillingCycleFilter>;
+export declare const UserPlanListRelationFilterSchema: z.ZodType<Prisma.UserPlanListRelationFilter>;
+export declare const UserPlanOrderByRelationAggregateInputSchema: z.ZodType<Prisma.UserPlanOrderByRelationAggregateInput>;
+export declare const PlanOrderByRelevanceInputSchema: z.ZodType<Prisma.PlanOrderByRelevanceInput>;
+export declare const PlanCountOrderByAggregateInputSchema: z.ZodType<Prisma.PlanCountOrderByAggregateInput>;
+export declare const PlanAvgOrderByAggregateInputSchema: z.ZodType<Prisma.PlanAvgOrderByAggregateInput>;
+export declare const PlanMaxOrderByAggregateInputSchema: z.ZodType<Prisma.PlanMaxOrderByAggregateInput>;
+export declare const PlanMinOrderByAggregateInputSchema: z.ZodType<Prisma.PlanMinOrderByAggregateInput>;
+export declare const PlanSumOrderByAggregateInputSchema: z.ZodType<Prisma.PlanSumOrderByAggregateInput>;
+export declare const EnumBillingCycleWithAggregatesFilterSchema: z.ZodType<Prisma.EnumBillingCycleWithAggregatesFilter>;
+export declare const PlanNodeGroupCountOrderByAggregateInputSchema: z.ZodType<Prisma.PlanNodeGroupCountOrderByAggregateInput>;
+export declare const PlanNodeGroupAvgOrderByAggregateInputSchema: z.ZodType<Prisma.PlanNodeGroupAvgOrderByAggregateInput>;
+export declare const PlanNodeGroupMaxOrderByAggregateInputSchema: z.ZodType<Prisma.PlanNodeGroupMaxOrderByAggregateInput>;
+export declare const PlanNodeGroupMinOrderByAggregateInputSchema: z.ZodType<Prisma.PlanNodeGroupMinOrderByAggregateInput>;
+export declare const PlanNodeGroupSumOrderByAggregateInputSchema: z.ZodType<Prisma.PlanNodeGroupSumOrderByAggregateInput>;
+export declare const PlanCouponNullableScalarRelationFilterSchema: z.ZodType<Prisma.PlanCouponNullableScalarRelationFilter>;
+export declare const PlanOrderCountOrderByAggregateInputSchema: z.ZodType<Prisma.PlanOrderCountOrderByAggregateInput>;
+export declare const PlanOrderAvgOrderByAggregateInputSchema: z.ZodType<Prisma.PlanOrderAvgOrderByAggregateInput>;
+export declare const PlanOrderMaxOrderByAggregateInputSchema: z.ZodType<Prisma.PlanOrderMaxOrderByAggregateInput>;
+export declare const PlanOrderMinOrderByAggregateInputSchema: z.ZodType<Prisma.PlanOrderMinOrderByAggregateInput>;
+export declare const PlanOrderSumOrderByAggregateInputSchema: z.ZodType<Prisma.PlanOrderSumOrderByAggregateInput>;
+export declare const EnumTopupOrderStatusFilterSchema: z.ZodType<Prisma.EnumTopupOrderStatusFilter>;
+export declare const PaymentScalarRelationFilterSchema: z.ZodType<Prisma.PaymentScalarRelationFilter>;
+export declare const TopupOrderOrderByRelevanceInputSchema: z.ZodType<Prisma.TopupOrderOrderByRelevanceInput>;
+export declare const TopupOrderCountOrderByAggregateInputSchema: z.ZodType<Prisma.TopupOrderCountOrderByAggregateInput>;
+export declare const TopupOrderAvgOrderByAggregateInputSchema: z.ZodType<Prisma.TopupOrderAvgOrderByAggregateInput>;
+export declare const TopupOrderMaxOrderByAggregateInputSchema: z.ZodType<Prisma.TopupOrderMaxOrderByAggregateInput>;
+export declare const TopupOrderMinOrderByAggregateInputSchema: z.ZodType<Prisma.TopupOrderMinOrderByAggregateInput>;
+export declare const TopupOrderSumOrderByAggregateInputSchema: z.ZodType<Prisma.TopupOrderSumOrderByAggregateInput>;
+export declare const EnumTopupOrderStatusWithAggregatesFilterSchema: z.ZodType<Prisma.EnumTopupOrderStatusWithAggregatesFilter>;
+export declare const EnumTopupActivityTypeFilterSchema: z.ZodType<Prisma.EnumTopupActivityTypeFilter>;
+export declare const TopupActivityCountOrderByAggregateInputSchema: z.ZodType<Prisma.TopupActivityCountOrderByAggregateInput>;
+export declare const TopupActivityAvgOrderByAggregateInputSchema: z.ZodType<Prisma.TopupActivityAvgOrderByAggregateInput>;
+export declare const TopupActivityMaxOrderByAggregateInputSchema: z.ZodType<Prisma.TopupActivityMaxOrderByAggregateInput>;
+export declare const TopupActivityMinOrderByAggregateInputSchema: z.ZodType<Prisma.TopupActivityMinOrderByAggregateInput>;
+export declare const TopupActivitySumOrderByAggregateInputSchema: z.ZodType<Prisma.TopupActivitySumOrderByAggregateInput>;
+export declare const EnumTopupActivityTypeWithAggregatesFilterSchema: z.ZodType<Prisma.EnumTopupActivityTypeWithAggregatesFilter>;
+export declare const TunnelTrafficCountOrderByAggregateInputSchema: z.ZodType<Prisma.TunnelTrafficCountOrderByAggregateInput>;
+export declare const TunnelTrafficAvgOrderByAggregateInputSchema: z.ZodType<Prisma.TunnelTrafficAvgOrderByAggregateInput>;
+export declare const TunnelTrafficMaxOrderByAggregateInputSchema: z.ZodType<Prisma.TunnelTrafficMaxOrderByAggregateInput>;
+export declare const TunnelTrafficMinOrderByAggregateInputSchema: z.ZodType<Prisma.TunnelTrafficMinOrderByAggregateInput>;
+export declare const TunnelTrafficSumOrderByAggregateInputSchema: z.ZodType<Prisma.TunnelTrafficSumOrderByAggregateInput>;
+export declare const EnumSystemConfigNameFilterSchema: z.ZodType<Prisma.EnumSystemConfigNameFilter>;
+export declare const SystemConfigOrderByRelevanceInputSchema: z.ZodType<Prisma.SystemConfigOrderByRelevanceInput>;
+export declare const SystemConfigCountOrderByAggregateInputSchema: z.ZodType<Prisma.SystemConfigCountOrderByAggregateInput>;
+export declare const SystemConfigAvgOrderByAggregateInputSchema: z.ZodType<Prisma.SystemConfigAvgOrderByAggregateInput>;
+export declare const SystemConfigMaxOrderByAggregateInputSchema: z.ZodType<Prisma.SystemConfigMaxOrderByAggregateInput>;
+export declare const SystemConfigMinOrderByAggregateInputSchema: z.ZodType<Prisma.SystemConfigMinOrderByAggregateInput>;
+export declare const SystemConfigSumOrderByAggregateInputSchema: z.ZodType<Prisma.SystemConfigSumOrderByAggregateInput>;
+export declare const EnumSystemConfigNameWithAggregatesFilterSchema: z.ZodType<Prisma.EnumSystemConfigNameWithAggregatesFilter>;
+export declare const EnumPaymentMethodFilterSchema: z.ZodType<Prisma.EnumPaymentMethodFilter>;
+export declare const PaymentOrderByRelevanceInputSchema: z.ZodType<Prisma.PaymentOrderByRelevanceInput>;
+export declare const PaymentCountOrderByAggregateInputSchema: z.ZodType<Prisma.PaymentCountOrderByAggregateInput>;
+export declare const PaymentAvgOrderByAggregateInputSchema: z.ZodType<Prisma.PaymentAvgOrderByAggregateInput>;
+export declare const PaymentMaxOrderByAggregateInputSchema: z.ZodType<Prisma.PaymentMaxOrderByAggregateInput>;
+export declare const PaymentMinOrderByAggregateInputSchema: z.ZodType<Prisma.PaymentMinOrderByAggregateInput>;
+export declare const PaymentSumOrderByAggregateInputSchema: z.ZodType<Prisma.PaymentSumOrderByAggregateInput>;
+export declare const EnumPaymentMethodWithAggregatesFilterSchema: z.ZodType<Prisma.EnumPaymentMethodWithAggregatesFilter>;
+export declare const EnumCouponTypeFilterSchema: z.ZodType<Prisma.EnumCouponTypeFilter>;
+export declare const EnumBillingCycleNullableFilterSchema: z.ZodType<Prisma.EnumBillingCycleNullableFilter>;
+export declare const PlanCouponOrderByRelevanceInputSchema: z.ZodType<Prisma.PlanCouponOrderByRelevanceInput>;
+export declare const PlanCouponCountOrderByAggregateInputSchema: z.ZodType<Prisma.PlanCouponCountOrderByAggregateInput>;
+export declare const PlanCouponAvgOrderByAggregateInputSchema: z.ZodType<Prisma.PlanCouponAvgOrderByAggregateInput>;
+export declare const PlanCouponMaxOrderByAggregateInputSchema: z.ZodType<Prisma.PlanCouponMaxOrderByAggregateInput>;
+export declare const PlanCouponMinOrderByAggregateInputSchema: z.ZodType<Prisma.PlanCouponMinOrderByAggregateInput>;
+export declare const PlanCouponSumOrderByAggregateInputSchema: z.ZodType<Prisma.PlanCouponSumOrderByAggregateInput>;
+export declare const EnumCouponTypeWithAggregatesFilterSchema: z.ZodType<Prisma.EnumCouponTypeWithAggregatesFilter>;
+export declare const EnumBillingCycleNullableWithAggregatesFilterSchema: z.ZodType<Prisma.EnumBillingCycleNullableWithAggregatesFilter>;
+export declare const EnumBalanceLogTypeFilterSchema: z.ZodType<Prisma.EnumBalanceLogTypeFilter>;
+export declare const BalanceLogCountOrderByAggregateInputSchema: z.ZodType<Prisma.BalanceLogCountOrderByAggregateInput>;
+export declare const BalanceLogAvgOrderByAggregateInputSchema: z.ZodType<Prisma.BalanceLogAvgOrderByAggregateInput>;
+export declare const BalanceLogMaxOrderByAggregateInputSchema: z.ZodType<Prisma.BalanceLogMaxOrderByAggregateInput>;
+export declare const BalanceLogMinOrderByAggregateInputSchema: z.ZodType<Prisma.BalanceLogMinOrderByAggregateInput>;
+export declare const BalanceLogSumOrderByAggregateInputSchema: z.ZodType<Prisma.BalanceLogSumOrderByAggregateInput>;
+export declare const EnumBalanceLogTypeWithAggregatesFilterSchema: z.ZodType<Prisma.EnumBalanceLogTypeWithAggregatesFilter>;
+export declare const EnumTicketStatusFilterSchema: z.ZodType<Prisma.EnumTicketStatusFilter>;
+export declare const TicketOrderByRelevanceInputSchema: z.ZodType<Prisma.TicketOrderByRelevanceInput>;
+export declare const TicketCountOrderByAggregateInputSchema: z.ZodType<Prisma.TicketCountOrderByAggregateInput>;
+export declare const TicketAvgOrderByAggregateInputSchema: z.ZodType<Prisma.TicketAvgOrderByAggregateInput>;
+export declare const TicketMaxOrderByAggregateInputSchema: z.ZodType<Prisma.TicketMaxOrderByAggregateInput>;
+export declare const TicketMinOrderByAggregateInputSchema: z.ZodType<Prisma.TicketMinOrderByAggregateInput>;
+export declare const TicketSumOrderByAggregateInputSchema: z.ZodType<Prisma.TicketSumOrderByAggregateInput>;
+export declare const EnumTicketStatusWithAggregatesFilterSchema: z.ZodType<Prisma.EnumTicketStatusWithAggregatesFilter>;
+export declare const TicketScalarRelationFilterSchema: z.ZodType<Prisma.TicketScalarRelationFilter>;
+export declare const TicketReplyOrderByRelevanceInputSchema: z.ZodType<Prisma.TicketReplyOrderByRelevanceInput>;
+export declare const TicketReplyCountOrderByAggregateInputSchema: z.ZodType<Prisma.TicketReplyCountOrderByAggregateInput>;
+export declare const TicketReplyAvgOrderByAggregateInputSchema: z.ZodType<Prisma.TicketReplyAvgOrderByAggregateInput>;
+export declare const TicketReplyMaxOrderByAggregateInputSchema: z.ZodType<Prisma.TicketReplyMaxOrderByAggregateInput>;
+export declare const TicketReplyMinOrderByAggregateInputSchema: z.ZodType<Prisma.TicketReplyMinOrderByAggregateInput>;
+export declare const TicketReplySumOrderByAggregateInputSchema: z.ZodType<Prisma.TicketReplySumOrderByAggregateInput>;
+export declare const DNSProviderScalarRelationFilterSchema: z.ZodType<Prisma.DNSProviderScalarRelationFilter>;
+export declare const InNodeGroupDNSCountOrderByAggregateInputSchema: z.ZodType<Prisma.InNodeGroupDNSCountOrderByAggregateInput>;
+export declare const InNodeGroupDNSAvgOrderByAggregateInputSchema: z.ZodType<Prisma.InNodeGroupDNSAvgOrderByAggregateInput>;
+export declare const InNodeGroupDNSMaxOrderByAggregateInputSchema: z.ZodType<Prisma.InNodeGroupDNSMaxOrderByAggregateInput>;
+export declare const InNodeGroupDNSMinOrderByAggregateInputSchema: z.ZodType<Prisma.InNodeGroupDNSMinOrderByAggregateInput>;
+export declare const InNodeGroupDNSSumOrderByAggregateInputSchema: z.ZodType<Prisma.InNodeGroupDNSSumOrderByAggregateInput>;
+export declare const EnumDNSProviderTypeFilterSchema: z.ZodType<Prisma.EnumDNSProviderTypeFilter>;
+export declare const DNSProviderOrderByRelevanceInputSchema: z.ZodType<Prisma.DNSProviderOrderByRelevanceInput>;
+export declare const DNSProviderCountOrderByAggregateInputSchema: z.ZodType<Prisma.DNSProviderCountOrderByAggregateInput>;
+export declare const DNSProviderAvgOrderByAggregateInputSchema: z.ZodType<Prisma.DNSProviderAvgOrderByAggregateInput>;
+export declare const DNSProviderMaxOrderByAggregateInputSchema: z.ZodType<Prisma.DNSProviderMaxOrderByAggregateInput>;
+export declare const DNSProviderMinOrderByAggregateInputSchema: z.ZodType<Prisma.DNSProviderMinOrderByAggregateInput>;
+export declare const DNSProviderSumOrderByAggregateInputSchema: z.ZodType<Prisma.DNSProviderSumOrderByAggregateInput>;
+export declare const EnumDNSProviderTypeWithAggregatesFilterSchema: z.ZodType<Prisma.EnumDNSProviderTypeWithAggregatesFilter>;
+export declare const UserCreateNestedOneWithoutNode_groupsInputSchema: z.ZodType<Prisma.UserCreateNestedOneWithoutNode_groupsInput>;
+export declare const TunnelCreateNestedManyWithoutIn_node_groupInputSchema: z.ZodType<Prisma.TunnelCreateNestedManyWithoutIn_node_groupInput>;
+export declare const TunnelCreateNestedManyWithoutOut_node_groupInputSchema: z.ZodType<Prisma.TunnelCreateNestedManyWithoutOut_node_groupInput>;
+export declare const NodeCreateNestedManyWithoutNode_groupInputSchema: z.ZodType<Prisma.NodeCreateNestedManyWithoutNode_groupInput>;
+export declare const PlanNodeGroupCreateNestedManyWithoutNode_groupInputSchema: z.ZodType<Prisma.PlanNodeGroupCreateNestedManyWithoutNode_groupInput>;
+export declare const TunnelChainCreateNestedManyWithoutNode_groupInputSchema: z.ZodType<Prisma.TunnelChainCreateNestedManyWithoutNode_groupInput>;
+export declare const InNodeGroupDNSCreateNestedManyWithoutIn_node_groupInputSchema: z.ZodType<Prisma.InNodeGroupDNSCreateNestedManyWithoutIn_node_groupInput>;
+export declare const TunnelUncheckedCreateNestedManyWithoutIn_node_groupInputSchema: z.ZodType<Prisma.TunnelUncheckedCreateNestedManyWithoutIn_node_groupInput>;
+export declare const TunnelUncheckedCreateNestedManyWithoutOut_node_groupInputSchema: z.ZodType<Prisma.TunnelUncheckedCreateNestedManyWithoutOut_node_groupInput>;
+export declare const NodeUncheckedCreateNestedManyWithoutNode_groupInputSchema: z.ZodType<Prisma.NodeUncheckedCreateNestedManyWithoutNode_groupInput>;
+export declare const PlanNodeGroupUncheckedCreateNestedManyWithoutNode_groupInputSchema: z.ZodType<Prisma.PlanNodeGroupUncheckedCreateNestedManyWithoutNode_groupInput>;
+export declare const TunnelChainUncheckedCreateNestedManyWithoutNode_groupInputSchema: z.ZodType<Prisma.TunnelChainUncheckedCreateNestedManyWithoutNode_groupInput>;
+export declare const InNodeGroupDNSUncheckedCreateNestedManyWithoutIn_node_groupInputSchema: z.ZodType<Prisma.InNodeGroupDNSUncheckedCreateNestedManyWithoutIn_node_groupInput>;
+export declare const StringFieldUpdateOperationsInputSchema: z.ZodType<Prisma.StringFieldUpdateOperationsInput>;
+export declare const NullableStringFieldUpdateOperationsInputSchema: z.ZodType<Prisma.NullableStringFieldUpdateOperationsInput>;
+export declare const EnumNodeTypeFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumNodeTypeFieldUpdateOperationsInput>;
+export declare const EnumLoadBalanceTypeFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumLoadBalanceTypeFieldUpdateOperationsInput>;
+export declare const BoolFieldUpdateOperationsInputSchema: z.ZodType<Prisma.BoolFieldUpdateOperationsInput>;
+export declare const EnumBypassTypeFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumBypassTypeFieldUpdateOperationsInput>;
+export declare const FloatFieldUpdateOperationsInputSchema: z.ZodType<Prisma.FloatFieldUpdateOperationsInput>;
+export declare const DateTimeFieldUpdateOperationsInputSchema: z.ZodType<Prisma.DateTimeFieldUpdateOperationsInput>;
+export declare const UserUpdateOneRequiredWithoutNode_groupsNestedInputSchema: z.ZodType<Prisma.UserUpdateOneRequiredWithoutNode_groupsNestedInput>;
+export declare const TunnelUpdateManyWithoutIn_node_groupNestedInputSchema: z.ZodType<Prisma.TunnelUpdateManyWithoutIn_node_groupNestedInput>;
+export declare const TunnelUpdateManyWithoutOut_node_groupNestedInputSchema: z.ZodType<Prisma.TunnelUpdateManyWithoutOut_node_groupNestedInput>;
+export declare const NodeUpdateManyWithoutNode_groupNestedInputSchema: z.ZodType<Prisma.NodeUpdateManyWithoutNode_groupNestedInput>;
+export declare const PlanNodeGroupUpdateManyWithoutNode_groupNestedInputSchema: z.ZodType<Prisma.PlanNodeGroupUpdateManyWithoutNode_groupNestedInput>;
+export declare const TunnelChainUpdateManyWithoutNode_groupNestedInputSchema: z.ZodType<Prisma.TunnelChainUpdateManyWithoutNode_groupNestedInput>;
+export declare const InNodeGroupDNSUpdateManyWithoutIn_node_groupNestedInputSchema: z.ZodType<Prisma.InNodeGroupDNSUpdateManyWithoutIn_node_groupNestedInput>;
+export declare const IntFieldUpdateOperationsInputSchema: z.ZodType<Prisma.IntFieldUpdateOperationsInput>;
+export declare const TunnelUncheckedUpdateManyWithoutIn_node_groupNestedInputSchema: z.ZodType<Prisma.TunnelUncheckedUpdateManyWithoutIn_node_groupNestedInput>;
+export declare const TunnelUncheckedUpdateManyWithoutOut_node_groupNestedInputSchema: z.ZodType<Prisma.TunnelUncheckedUpdateManyWithoutOut_node_groupNestedInput>;
+export declare const NodeUncheckedUpdateManyWithoutNode_groupNestedInputSchema: z.ZodType<Prisma.NodeUncheckedUpdateManyWithoutNode_groupNestedInput>;
+export declare const PlanNodeGroupUncheckedUpdateManyWithoutNode_groupNestedInputSchema: z.ZodType<Prisma.PlanNodeGroupUncheckedUpdateManyWithoutNode_groupNestedInput>;
+export declare const TunnelChainUncheckedUpdateManyWithoutNode_groupNestedInputSchema: z.ZodType<Prisma.TunnelChainUncheckedUpdateManyWithoutNode_groupNestedInput>;
+export declare const InNodeGroupDNSUncheckedUpdateManyWithoutIn_node_groupNestedInputSchema: z.ZodType<Prisma.InNodeGroupDNSUncheckedUpdateManyWithoutIn_node_groupNestedInput>;
+export declare const NodeGroupCreateNestedOneWithoutNodesInputSchema: z.ZodType<Prisma.NodeGroupCreateNestedOneWithoutNodesInput>;
+export declare const EnumStatusFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumStatusFieldUpdateOperationsInput>;
+export declare const NodeGroupUpdateOneRequiredWithoutNodesNestedInputSchema: z.ZodType<Prisma.NodeGroupUpdateOneRequiredWithoutNodesNestedInput>;
+export declare const NodeGroupCreateNestedOneWithoutIn_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupCreateNestedOneWithoutIn_tunnelsInput>;
+export declare const NodeGroupCreateNestedOneWithoutOut_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupCreateNestedOneWithoutOut_tunnelsInput>;
+export declare const UserCreateNestedOneWithoutTunnelsInputSchema: z.ZodType<Prisma.UserCreateNestedOneWithoutTunnelsInput>;
+export declare const TunnelTrafficCreateNestedManyWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelTrafficCreateNestedManyWithoutTunnelInput>;
+export declare const TunnelChainCreateNestedManyWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelChainCreateNestedManyWithoutTunnelInput>;
+export declare const TunnelTrafficUncheckedCreateNestedManyWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelTrafficUncheckedCreateNestedManyWithoutTunnelInput>;
+export declare const TunnelChainUncheckedCreateNestedManyWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelChainUncheckedCreateNestedManyWithoutTunnelInput>;
+export declare const EnumTunnelTypeFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumTunnelTypeFieldUpdateOperationsInput>;
+export declare const EnumTunnelCategoryFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumTunnelCategoryFieldUpdateOperationsInput>;
+export declare const NullableIntFieldUpdateOperationsInputSchema: z.ZodType<Prisma.NullableIntFieldUpdateOperationsInput>;
+export declare const EnumIpTypeFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumIpTypeFieldUpdateOperationsInput>;
+export declare const NodeGroupUpdateOneRequiredWithoutIn_tunnelsNestedInputSchema: z.ZodType<Prisma.NodeGroupUpdateOneRequiredWithoutIn_tunnelsNestedInput>;
+export declare const NodeGroupUpdateOneWithoutOut_tunnelsNestedInputSchema: z.ZodType<Prisma.NodeGroupUpdateOneWithoutOut_tunnelsNestedInput>;
+export declare const UserUpdateOneRequiredWithoutTunnelsNestedInputSchema: z.ZodType<Prisma.UserUpdateOneRequiredWithoutTunnelsNestedInput>;
+export declare const TunnelTrafficUpdateManyWithoutTunnelNestedInputSchema: z.ZodType<Prisma.TunnelTrafficUpdateManyWithoutTunnelNestedInput>;
+export declare const TunnelChainUpdateManyWithoutTunnelNestedInputSchema: z.ZodType<Prisma.TunnelChainUpdateManyWithoutTunnelNestedInput>;
+export declare const TunnelTrafficUncheckedUpdateManyWithoutTunnelNestedInputSchema: z.ZodType<Prisma.TunnelTrafficUncheckedUpdateManyWithoutTunnelNestedInput>;
+export declare const TunnelChainUncheckedUpdateManyWithoutTunnelNestedInputSchema: z.ZodType<Prisma.TunnelChainUncheckedUpdateManyWithoutTunnelNestedInput>;
+export declare const TunnelCreateNestedOneWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.TunnelCreateNestedOneWithoutTunnel_chainsInput>;
+export declare const NodeGroupCreateNestedOneWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.NodeGroupCreateNestedOneWithoutTunnel_chainsInput>;
+export declare const TunnelUpdateOneRequiredWithoutTunnel_chainsNestedInputSchema: z.ZodType<Prisma.TunnelUpdateOneRequiredWithoutTunnel_chainsNestedInput>;
+export declare const NodeGroupUpdateOneRequiredWithoutTunnel_chainsNestedInputSchema: z.ZodType<Prisma.NodeGroupUpdateOneRequiredWithoutTunnel_chainsNestedInput>;
+export declare const TunnelCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.TunnelCreateNestedManyWithoutUserInput>;
+export declare const UserCreateNestedOneWithoutChildrenInputSchema: z.ZodType<Prisma.UserCreateNestedOneWithoutChildrenInput>;
+export declare const UserCreateNestedManyWithoutParentInputSchema: z.ZodType<Prisma.UserCreateNestedManyWithoutParentInput>;
+export declare const NodeGroupCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.NodeGroupCreateNestedManyWithoutUserInput>;
+export declare const PlanOrderCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.PlanOrderCreateNestedManyWithoutUserInput>;
+export declare const TopupOrderCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.TopupOrderCreateNestedManyWithoutUserInput>;
+export declare const UserPlanCreateNestedOneWithoutUserInputSchema: z.ZodType<Prisma.UserPlanCreateNestedOneWithoutUserInput>;
+export declare const BalanceLogCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.BalanceLogCreateNestedManyWithoutUserInput>;
+export declare const TicketCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.TicketCreateNestedManyWithoutUserInput>;
+export declare const TicketReplyCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.TicketReplyCreateNestedManyWithoutUserInput>;
+export declare const TunnelUncheckedCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.TunnelUncheckedCreateNestedManyWithoutUserInput>;
+export declare const UserUncheckedCreateNestedManyWithoutParentInputSchema: z.ZodType<Prisma.UserUncheckedCreateNestedManyWithoutParentInput>;
+export declare const NodeGroupUncheckedCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.NodeGroupUncheckedCreateNestedManyWithoutUserInput>;
+export declare const PlanOrderUncheckedCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.PlanOrderUncheckedCreateNestedManyWithoutUserInput>;
+export declare const TopupOrderUncheckedCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.TopupOrderUncheckedCreateNestedManyWithoutUserInput>;
+export declare const UserPlanUncheckedCreateNestedOneWithoutUserInputSchema: z.ZodType<Prisma.UserPlanUncheckedCreateNestedOneWithoutUserInput>;
+export declare const BalanceLogUncheckedCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.BalanceLogUncheckedCreateNestedManyWithoutUserInput>;
+export declare const TicketUncheckedCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.TicketUncheckedCreateNestedManyWithoutUserInput>;
+export declare const TicketReplyUncheckedCreateNestedManyWithoutUserInputSchema: z.ZodType<Prisma.TicketReplyUncheckedCreateNestedManyWithoutUserInput>;
+export declare const NullableFloatFieldUpdateOperationsInputSchema: z.ZodType<Prisma.NullableFloatFieldUpdateOperationsInput>;
+export declare const NullableBoolFieldUpdateOperationsInputSchema: z.ZodType<Prisma.NullableBoolFieldUpdateOperationsInput>;
+export declare const TunnelUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.TunnelUpdateManyWithoutUserNestedInput>;
+export declare const UserUpdateOneWithoutChildrenNestedInputSchema: z.ZodType<Prisma.UserUpdateOneWithoutChildrenNestedInput>;
+export declare const UserUpdateManyWithoutParentNestedInputSchema: z.ZodType<Prisma.UserUpdateManyWithoutParentNestedInput>;
+export declare const NodeGroupUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.NodeGroupUpdateManyWithoutUserNestedInput>;
+export declare const PlanOrderUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.PlanOrderUpdateManyWithoutUserNestedInput>;
+export declare const TopupOrderUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.TopupOrderUpdateManyWithoutUserNestedInput>;
+export declare const UserPlanUpdateOneWithoutUserNestedInputSchema: z.ZodType<Prisma.UserPlanUpdateOneWithoutUserNestedInput>;
+export declare const BalanceLogUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.BalanceLogUpdateManyWithoutUserNestedInput>;
+export declare const TicketUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.TicketUpdateManyWithoutUserNestedInput>;
+export declare const TicketReplyUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.TicketReplyUpdateManyWithoutUserNestedInput>;
+export declare const TunnelUncheckedUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.TunnelUncheckedUpdateManyWithoutUserNestedInput>;
+export declare const UserUncheckedUpdateManyWithoutParentNestedInputSchema: z.ZodType<Prisma.UserUncheckedUpdateManyWithoutParentNestedInput>;
+export declare const NodeGroupUncheckedUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.NodeGroupUncheckedUpdateManyWithoutUserNestedInput>;
+export declare const PlanOrderUncheckedUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.PlanOrderUncheckedUpdateManyWithoutUserNestedInput>;
+export declare const TopupOrderUncheckedUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.TopupOrderUncheckedUpdateManyWithoutUserNestedInput>;
+export declare const UserPlanUncheckedUpdateOneWithoutUserNestedInputSchema: z.ZodType<Prisma.UserPlanUncheckedUpdateOneWithoutUserNestedInput>;
+export declare const BalanceLogUncheckedUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.BalanceLogUncheckedUpdateManyWithoutUserNestedInput>;
+export declare const TicketUncheckedUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.TicketUncheckedUpdateManyWithoutUserNestedInput>;
+export declare const TicketReplyUncheckedUpdateManyWithoutUserNestedInputSchema: z.ZodType<Prisma.TicketReplyUncheckedUpdateManyWithoutUserNestedInput>;
+export declare const UserCreateNestedOneWithoutUser_planInputSchema: z.ZodType<Prisma.UserCreateNestedOneWithoutUser_planInput>;
+export declare const PlanCreateNestedOneWithoutUser_plansInputSchema: z.ZodType<Prisma.PlanCreateNestedOneWithoutUser_plansInput>;
+export declare const NullableDateTimeFieldUpdateOperationsInputSchema: z.ZodType<Prisma.NullableDateTimeFieldUpdateOperationsInput>;
+export declare const UserUpdateOneRequiredWithoutUser_planNestedInputSchema: z.ZodType<Prisma.UserUpdateOneRequiredWithoutUser_planNestedInput>;
+export declare const PlanUpdateOneRequiredWithoutUser_plansNestedInputSchema: z.ZodType<Prisma.PlanUpdateOneRequiredWithoutUser_plansNestedInput>;
+export declare const PlanNodeGroupCreateNestedManyWithoutPlanInputSchema: z.ZodType<Prisma.PlanNodeGroupCreateNestedManyWithoutPlanInput>;
+export declare const PlanOrderCreateNestedManyWithoutPlanInputSchema: z.ZodType<Prisma.PlanOrderCreateNestedManyWithoutPlanInput>;
+export declare const UserPlanCreateNestedManyWithoutPlanInputSchema: z.ZodType<Prisma.UserPlanCreateNestedManyWithoutPlanInput>;
+export declare const PlanNodeGroupUncheckedCreateNestedManyWithoutPlanInputSchema: z.ZodType<Prisma.PlanNodeGroupUncheckedCreateNestedManyWithoutPlanInput>;
+export declare const PlanOrderUncheckedCreateNestedManyWithoutPlanInputSchema: z.ZodType<Prisma.PlanOrderUncheckedCreateNestedManyWithoutPlanInput>;
+export declare const UserPlanUncheckedCreateNestedManyWithoutPlanInputSchema: z.ZodType<Prisma.UserPlanUncheckedCreateNestedManyWithoutPlanInput>;
+export declare const EnumBillingCycleFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumBillingCycleFieldUpdateOperationsInput>;
+export declare const PlanNodeGroupUpdateManyWithoutPlanNestedInputSchema: z.ZodType<Prisma.PlanNodeGroupUpdateManyWithoutPlanNestedInput>;
+export declare const PlanOrderUpdateManyWithoutPlanNestedInputSchema: z.ZodType<Prisma.PlanOrderUpdateManyWithoutPlanNestedInput>;
+export declare const UserPlanUpdateManyWithoutPlanNestedInputSchema: z.ZodType<Prisma.UserPlanUpdateManyWithoutPlanNestedInput>;
+export declare const PlanNodeGroupUncheckedUpdateManyWithoutPlanNestedInputSchema: z.ZodType<Prisma.PlanNodeGroupUncheckedUpdateManyWithoutPlanNestedInput>;
+export declare const PlanOrderUncheckedUpdateManyWithoutPlanNestedInputSchema: z.ZodType<Prisma.PlanOrderUncheckedUpdateManyWithoutPlanNestedInput>;
+export declare const UserPlanUncheckedUpdateManyWithoutPlanNestedInputSchema: z.ZodType<Prisma.UserPlanUncheckedUpdateManyWithoutPlanNestedInput>;
+export declare const NodeGroupCreateNestedOneWithoutPlansInputSchema: z.ZodType<Prisma.NodeGroupCreateNestedOneWithoutPlansInput>;
+export declare const PlanCreateNestedOneWithoutNode_groupsInputSchema: z.ZodType<Prisma.PlanCreateNestedOneWithoutNode_groupsInput>;
+export declare const NodeGroupUpdateOneRequiredWithoutPlansNestedInputSchema: z.ZodType<Prisma.NodeGroupUpdateOneRequiredWithoutPlansNestedInput>;
+export declare const PlanUpdateOneRequiredWithoutNode_groupsNestedInputSchema: z.ZodType<Prisma.PlanUpdateOneRequiredWithoutNode_groupsNestedInput>;
+export declare const UserCreateNestedOneWithoutOrdersInputSchema: z.ZodType<Prisma.UserCreateNestedOneWithoutOrdersInput>;
+export declare const PlanCreateNestedOneWithoutOrdersInputSchema: z.ZodType<Prisma.PlanCreateNestedOneWithoutOrdersInput>;
+export declare const PlanCouponCreateNestedOneWithoutOrdersInputSchema: z.ZodType<Prisma.PlanCouponCreateNestedOneWithoutOrdersInput>;
+export declare const UserUpdateOneRequiredWithoutOrdersNestedInputSchema: z.ZodType<Prisma.UserUpdateOneRequiredWithoutOrdersNestedInput>;
+export declare const PlanUpdateOneRequiredWithoutOrdersNestedInputSchema: z.ZodType<Prisma.PlanUpdateOneRequiredWithoutOrdersNestedInput>;
+export declare const PlanCouponUpdateOneWithoutOrdersNestedInputSchema: z.ZodType<Prisma.PlanCouponUpdateOneWithoutOrdersNestedInput>;
+export declare const UserCreateNestedOneWithoutTopupsInputSchema: z.ZodType<Prisma.UserCreateNestedOneWithoutTopupsInput>;
+export declare const PaymentCreateNestedOneWithoutTopupsInputSchema: z.ZodType<Prisma.PaymentCreateNestedOneWithoutTopupsInput>;
+export declare const EnumTopupOrderStatusFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumTopupOrderStatusFieldUpdateOperationsInput>;
+export declare const UserUpdateOneRequiredWithoutTopupsNestedInputSchema: z.ZodType<Prisma.UserUpdateOneRequiredWithoutTopupsNestedInput>;
+export declare const PaymentUpdateOneRequiredWithoutTopupsNestedInputSchema: z.ZodType<Prisma.PaymentUpdateOneRequiredWithoutTopupsNestedInput>;
+export declare const EnumTopupActivityTypeFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumTopupActivityTypeFieldUpdateOperationsInput>;
+export declare const TunnelCreateNestedOneWithoutTunnel_trafficInputSchema: z.ZodType<Prisma.TunnelCreateNestedOneWithoutTunnel_trafficInput>;
+export declare const TunnelUpdateOneRequiredWithoutTunnel_trafficNestedInputSchema: z.ZodType<Prisma.TunnelUpdateOneRequiredWithoutTunnel_trafficNestedInput>;
+export declare const EnumSystemConfigNameFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumSystemConfigNameFieldUpdateOperationsInput>;
+export declare const TopupOrderCreateNestedManyWithoutPaymentInputSchema: z.ZodType<Prisma.TopupOrderCreateNestedManyWithoutPaymentInput>;
+export declare const TopupOrderUncheckedCreateNestedManyWithoutPaymentInputSchema: z.ZodType<Prisma.TopupOrderUncheckedCreateNestedManyWithoutPaymentInput>;
+export declare const EnumPaymentMethodFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumPaymentMethodFieldUpdateOperationsInput>;
+export declare const TopupOrderUpdateManyWithoutPaymentNestedInputSchema: z.ZodType<Prisma.TopupOrderUpdateManyWithoutPaymentNestedInput>;
+export declare const TopupOrderUncheckedUpdateManyWithoutPaymentNestedInputSchema: z.ZodType<Prisma.TopupOrderUncheckedUpdateManyWithoutPaymentNestedInput>;
+export declare const PlanOrderCreateNestedManyWithoutCouponInputSchema: z.ZodType<Prisma.PlanOrderCreateNestedManyWithoutCouponInput>;
+export declare const PlanOrderUncheckedCreateNestedManyWithoutCouponInputSchema: z.ZodType<Prisma.PlanOrderUncheckedCreateNestedManyWithoutCouponInput>;
+export declare const EnumCouponTypeFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumCouponTypeFieldUpdateOperationsInput>;
+export declare const NullableEnumBillingCycleFieldUpdateOperationsInputSchema: z.ZodType<Prisma.NullableEnumBillingCycleFieldUpdateOperationsInput>;
+export declare const PlanOrderUpdateManyWithoutCouponNestedInputSchema: z.ZodType<Prisma.PlanOrderUpdateManyWithoutCouponNestedInput>;
+export declare const PlanOrderUncheckedUpdateManyWithoutCouponNestedInputSchema: z.ZodType<Prisma.PlanOrderUncheckedUpdateManyWithoutCouponNestedInput>;
+export declare const UserCreateNestedOneWithoutBalance_logsInputSchema: z.ZodType<Prisma.UserCreateNestedOneWithoutBalance_logsInput>;
+export declare const EnumBalanceLogTypeFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumBalanceLogTypeFieldUpdateOperationsInput>;
+export declare const UserUpdateOneRequiredWithoutBalance_logsNestedInputSchema: z.ZodType<Prisma.UserUpdateOneRequiredWithoutBalance_logsNestedInput>;
+export declare const UserCreateNestedOneWithoutTicketsInputSchema: z.ZodType<Prisma.UserCreateNestedOneWithoutTicketsInput>;
+export declare const TicketReplyCreateNestedManyWithoutTicketInputSchema: z.ZodType<Prisma.TicketReplyCreateNestedManyWithoutTicketInput>;
+export declare const TicketReplyUncheckedCreateNestedManyWithoutTicketInputSchema: z.ZodType<Prisma.TicketReplyUncheckedCreateNestedManyWithoutTicketInput>;
+export declare const EnumTicketStatusFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumTicketStatusFieldUpdateOperationsInput>;
+export declare const UserUpdateOneRequiredWithoutTicketsNestedInputSchema: z.ZodType<Prisma.UserUpdateOneRequiredWithoutTicketsNestedInput>;
+export declare const TicketReplyUpdateManyWithoutTicketNestedInputSchema: z.ZodType<Prisma.TicketReplyUpdateManyWithoutTicketNestedInput>;
+export declare const TicketReplyUncheckedUpdateManyWithoutTicketNestedInputSchema: z.ZodType<Prisma.TicketReplyUncheckedUpdateManyWithoutTicketNestedInput>;
+export declare const TicketCreateNestedOneWithoutRepliesInputSchema: z.ZodType<Prisma.TicketCreateNestedOneWithoutRepliesInput>;
+export declare const UserCreateNestedOneWithoutTicket_repliesInputSchema: z.ZodType<Prisma.UserCreateNestedOneWithoutTicket_repliesInput>;
+export declare const TicketUpdateOneRequiredWithoutRepliesNestedInputSchema: z.ZodType<Prisma.TicketUpdateOneRequiredWithoutRepliesNestedInput>;
+export declare const UserUpdateOneRequiredWithoutTicket_repliesNestedInputSchema: z.ZodType<Prisma.UserUpdateOneRequiredWithoutTicket_repliesNestedInput>;
+export declare const NodeGroupCreateNestedOneWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.NodeGroupCreateNestedOneWithoutIn_node_group_dnsInput>;
+export declare const DNSProviderCreateNestedOneWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.DNSProviderCreateNestedOneWithoutIn_node_group_dnsInput>;
+export declare const NodeGroupUpdateOneRequiredWithoutIn_node_group_dnsNestedInputSchema: z.ZodType<Prisma.NodeGroupUpdateOneRequiredWithoutIn_node_group_dnsNestedInput>;
+export declare const DNSProviderUpdateOneRequiredWithoutIn_node_group_dnsNestedInputSchema: z.ZodType<Prisma.DNSProviderUpdateOneRequiredWithoutIn_node_group_dnsNestedInput>;
+export declare const InNodeGroupDNSCreateNestedManyWithoutDns_providerInputSchema: z.ZodType<Prisma.InNodeGroupDNSCreateNestedManyWithoutDns_providerInput>;
+export declare const InNodeGroupDNSUncheckedCreateNestedManyWithoutDns_providerInputSchema: z.ZodType<Prisma.InNodeGroupDNSUncheckedCreateNestedManyWithoutDns_providerInput>;
+export declare const EnumDNSProviderTypeFieldUpdateOperationsInputSchema: z.ZodType<Prisma.EnumDNSProviderTypeFieldUpdateOperationsInput>;
+export declare const InNodeGroupDNSUpdateManyWithoutDns_providerNestedInputSchema: z.ZodType<Prisma.InNodeGroupDNSUpdateManyWithoutDns_providerNestedInput>;
+export declare const InNodeGroupDNSUncheckedUpdateManyWithoutDns_providerNestedInputSchema: z.ZodType<Prisma.InNodeGroupDNSUncheckedUpdateManyWithoutDns_providerNestedInput>;
+export declare const NestedIntFilterSchema: z.ZodType<Prisma.NestedIntFilter>;
+export declare const NestedStringFilterSchema: z.ZodType<Prisma.NestedStringFilter>;
+export declare const NestedStringNullableFilterSchema: z.ZodType<Prisma.NestedStringNullableFilter>;
+export declare const NestedEnumNodeTypeFilterSchema: z.ZodType<Prisma.NestedEnumNodeTypeFilter>;
+export declare const NestedEnumLoadBalanceTypeFilterSchema: z.ZodType<Prisma.NestedEnumLoadBalanceTypeFilter>;
+export declare const NestedBoolFilterSchema: z.ZodType<Prisma.NestedBoolFilter>;
+export declare const NestedEnumBypassTypeFilterSchema: z.ZodType<Prisma.NestedEnumBypassTypeFilter>;
+export declare const NestedFloatFilterSchema: z.ZodType<Prisma.NestedFloatFilter>;
+export declare const NestedDateTimeFilterSchema: z.ZodType<Prisma.NestedDateTimeFilter>;
+export declare const NestedIntWithAggregatesFilterSchema: z.ZodType<Prisma.NestedIntWithAggregatesFilter>;
+export declare const NestedStringWithAggregatesFilterSchema: z.ZodType<Prisma.NestedStringWithAggregatesFilter>;
+export declare const NestedStringNullableWithAggregatesFilterSchema: z.ZodType<Prisma.NestedStringNullableWithAggregatesFilter>;
+export declare const NestedIntNullableFilterSchema: z.ZodType<Prisma.NestedIntNullableFilter>;
+export declare const NestedEnumNodeTypeWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumNodeTypeWithAggregatesFilter>;
+export declare const NestedEnumLoadBalanceTypeWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumLoadBalanceTypeWithAggregatesFilter>;
+export declare const NestedBoolWithAggregatesFilterSchema: z.ZodType<Prisma.NestedBoolWithAggregatesFilter>;
+export declare const NestedJsonNullableFilterSchema: z.ZodType<Prisma.NestedJsonNullableFilter>;
+export declare const NestedEnumBypassTypeWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumBypassTypeWithAggregatesFilter>;
+export declare const NestedFloatWithAggregatesFilterSchema: z.ZodType<Prisma.NestedFloatWithAggregatesFilter>;
+export declare const NestedDateTimeWithAggregatesFilterSchema: z.ZodType<Prisma.NestedDateTimeWithAggregatesFilter>;
+export declare const NestedEnumStatusFilterSchema: z.ZodType<Prisma.NestedEnumStatusFilter>;
+export declare const NestedEnumStatusWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumStatusWithAggregatesFilter>;
+export declare const NestedEnumTunnelTypeFilterSchema: z.ZodType<Prisma.NestedEnumTunnelTypeFilter>;
+export declare const NestedEnumTunnelCategoryFilterSchema: z.ZodType<Prisma.NestedEnumTunnelCategoryFilter>;
+export declare const NestedEnumIpTypeFilterSchema: z.ZodType<Prisma.NestedEnumIpTypeFilter>;
+export declare const NestedEnumTunnelTypeWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumTunnelTypeWithAggregatesFilter>;
+export declare const NestedEnumTunnelCategoryWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumTunnelCategoryWithAggregatesFilter>;
+export declare const NestedIntNullableWithAggregatesFilterSchema: z.ZodType<Prisma.NestedIntNullableWithAggregatesFilter>;
+export declare const NestedFloatNullableFilterSchema: z.ZodType<Prisma.NestedFloatNullableFilter>;
+export declare const NestedJsonFilterSchema: z.ZodType<Prisma.NestedJsonFilter>;
+export declare const NestedEnumIpTypeWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumIpTypeWithAggregatesFilter>;
+export declare const NestedBoolNullableFilterSchema: z.ZodType<Prisma.NestedBoolNullableFilter>;
+export declare const NestedFloatNullableWithAggregatesFilterSchema: z.ZodType<Prisma.NestedFloatNullableWithAggregatesFilter>;
+export declare const NestedBoolNullableWithAggregatesFilterSchema: z.ZodType<Prisma.NestedBoolNullableWithAggregatesFilter>;
+export declare const NestedDateTimeNullableFilterSchema: z.ZodType<Prisma.NestedDateTimeNullableFilter>;
+export declare const NestedDateTimeNullableWithAggregatesFilterSchema: z.ZodType<Prisma.NestedDateTimeNullableWithAggregatesFilter>;
+export declare const NestedEnumBillingCycleFilterSchema: z.ZodType<Prisma.NestedEnumBillingCycleFilter>;
+export declare const NestedEnumBillingCycleWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumBillingCycleWithAggregatesFilter>;
+export declare const NestedEnumTopupOrderStatusFilterSchema: z.ZodType<Prisma.NestedEnumTopupOrderStatusFilter>;
+export declare const NestedEnumTopupOrderStatusWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumTopupOrderStatusWithAggregatesFilter>;
+export declare const NestedEnumTopupActivityTypeFilterSchema: z.ZodType<Prisma.NestedEnumTopupActivityTypeFilter>;
+export declare const NestedEnumTopupActivityTypeWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumTopupActivityTypeWithAggregatesFilter>;
+export declare const NestedEnumSystemConfigNameFilterSchema: z.ZodType<Prisma.NestedEnumSystemConfigNameFilter>;
+export declare const NestedEnumSystemConfigNameWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumSystemConfigNameWithAggregatesFilter>;
+export declare const NestedEnumPaymentMethodFilterSchema: z.ZodType<Prisma.NestedEnumPaymentMethodFilter>;
+export declare const NestedEnumPaymentMethodWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumPaymentMethodWithAggregatesFilter>;
+export declare const NestedEnumCouponTypeFilterSchema: z.ZodType<Prisma.NestedEnumCouponTypeFilter>;
+export declare const NestedEnumBillingCycleNullableFilterSchema: z.ZodType<Prisma.NestedEnumBillingCycleNullableFilter>;
+export declare const NestedEnumCouponTypeWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumCouponTypeWithAggregatesFilter>;
+export declare const NestedEnumBillingCycleNullableWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumBillingCycleNullableWithAggregatesFilter>;
+export declare const NestedEnumBalanceLogTypeFilterSchema: z.ZodType<Prisma.NestedEnumBalanceLogTypeFilter>;
+export declare const NestedEnumBalanceLogTypeWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumBalanceLogTypeWithAggregatesFilter>;
+export declare const NestedEnumTicketStatusFilterSchema: z.ZodType<Prisma.NestedEnumTicketStatusFilter>;
+export declare const NestedEnumTicketStatusWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumTicketStatusWithAggregatesFilter>;
+export declare const NestedEnumDNSProviderTypeFilterSchema: z.ZodType<Prisma.NestedEnumDNSProviderTypeFilter>;
+export declare const NestedEnumDNSProviderTypeWithAggregatesFilterSchema: z.ZodType<Prisma.NestedEnumDNSProviderTypeWithAggregatesFilter>;
+export declare const UserCreateWithoutNode_groupsInputSchema: z.ZodType<Prisma.UserCreateWithoutNode_groupsInput>;
+export declare const UserUncheckedCreateWithoutNode_groupsInputSchema: z.ZodType<Prisma.UserUncheckedCreateWithoutNode_groupsInput>;
+export declare const UserCreateOrConnectWithoutNode_groupsInputSchema: z.ZodType<Prisma.UserCreateOrConnectWithoutNode_groupsInput>;
+export declare const TunnelCreateWithoutIn_node_groupInputSchema: z.ZodType<Prisma.TunnelCreateWithoutIn_node_groupInput>;
+export declare const TunnelUncheckedCreateWithoutIn_node_groupInputSchema: z.ZodType<Prisma.TunnelUncheckedCreateWithoutIn_node_groupInput>;
+export declare const TunnelCreateOrConnectWithoutIn_node_groupInputSchema: z.ZodType<Prisma.TunnelCreateOrConnectWithoutIn_node_groupInput>;
+export declare const TunnelCreateManyIn_node_groupInputEnvelopeSchema: z.ZodType<Prisma.TunnelCreateManyIn_node_groupInputEnvelope>;
+export declare const TunnelCreateWithoutOut_node_groupInputSchema: z.ZodType<Prisma.TunnelCreateWithoutOut_node_groupInput>;
+export declare const TunnelUncheckedCreateWithoutOut_node_groupInputSchema: z.ZodType<Prisma.TunnelUncheckedCreateWithoutOut_node_groupInput>;
+export declare const TunnelCreateOrConnectWithoutOut_node_groupInputSchema: z.ZodType<Prisma.TunnelCreateOrConnectWithoutOut_node_groupInput>;
+export declare const TunnelCreateManyOut_node_groupInputEnvelopeSchema: z.ZodType<Prisma.TunnelCreateManyOut_node_groupInputEnvelope>;
+export declare const NodeCreateWithoutNode_groupInputSchema: z.ZodType<Prisma.NodeCreateWithoutNode_groupInput>;
+export declare const NodeUncheckedCreateWithoutNode_groupInputSchema: z.ZodType<Prisma.NodeUncheckedCreateWithoutNode_groupInput>;
+export declare const NodeCreateOrConnectWithoutNode_groupInputSchema: z.ZodType<Prisma.NodeCreateOrConnectWithoutNode_groupInput>;
+export declare const NodeCreateManyNode_groupInputEnvelopeSchema: z.ZodType<Prisma.NodeCreateManyNode_groupInputEnvelope>;
+export declare const PlanNodeGroupCreateWithoutNode_groupInputSchema: z.ZodType<Prisma.PlanNodeGroupCreateWithoutNode_groupInput>;
+export declare const PlanNodeGroupUncheckedCreateWithoutNode_groupInputSchema: z.ZodType<Prisma.PlanNodeGroupUncheckedCreateWithoutNode_groupInput>;
+export declare const PlanNodeGroupCreateOrConnectWithoutNode_groupInputSchema: z.ZodType<Prisma.PlanNodeGroupCreateOrConnectWithoutNode_groupInput>;
+export declare const PlanNodeGroupCreateManyNode_groupInputEnvelopeSchema: z.ZodType<Prisma.PlanNodeGroupCreateManyNode_groupInputEnvelope>;
+export declare const TunnelChainCreateWithoutNode_groupInputSchema: z.ZodType<Prisma.TunnelChainCreateWithoutNode_groupInput>;
+export declare const TunnelChainUncheckedCreateWithoutNode_groupInputSchema: z.ZodType<Prisma.TunnelChainUncheckedCreateWithoutNode_groupInput>;
+export declare const TunnelChainCreateOrConnectWithoutNode_groupInputSchema: z.ZodType<Prisma.TunnelChainCreateOrConnectWithoutNode_groupInput>;
+export declare const TunnelChainCreateManyNode_groupInputEnvelopeSchema: z.ZodType<Prisma.TunnelChainCreateManyNode_groupInputEnvelope>;
+export declare const InNodeGroupDNSCreateWithoutIn_node_groupInputSchema: z.ZodType<Prisma.InNodeGroupDNSCreateWithoutIn_node_groupInput>;
+export declare const InNodeGroupDNSUncheckedCreateWithoutIn_node_groupInputSchema: z.ZodType<Prisma.InNodeGroupDNSUncheckedCreateWithoutIn_node_groupInput>;
+export declare const InNodeGroupDNSCreateOrConnectWithoutIn_node_groupInputSchema: z.ZodType<Prisma.InNodeGroupDNSCreateOrConnectWithoutIn_node_groupInput>;
+export declare const InNodeGroupDNSCreateManyIn_node_groupInputEnvelopeSchema: z.ZodType<Prisma.InNodeGroupDNSCreateManyIn_node_groupInputEnvelope>;
+export declare const UserUpsertWithoutNode_groupsInputSchema: z.ZodType<Prisma.UserUpsertWithoutNode_groupsInput>;
+export declare const UserUpdateToOneWithWhereWithoutNode_groupsInputSchema: z.ZodType<Prisma.UserUpdateToOneWithWhereWithoutNode_groupsInput>;
+export declare const UserUpdateWithoutNode_groupsInputSchema: z.ZodType<Prisma.UserUpdateWithoutNode_groupsInput>;
+export declare const UserUncheckedUpdateWithoutNode_groupsInputSchema: z.ZodType<Prisma.UserUncheckedUpdateWithoutNode_groupsInput>;
+export declare const TunnelUpsertWithWhereUniqueWithoutIn_node_groupInputSchema: z.ZodType<Prisma.TunnelUpsertWithWhereUniqueWithoutIn_node_groupInput>;
+export declare const TunnelUpdateWithWhereUniqueWithoutIn_node_groupInputSchema: z.ZodType<Prisma.TunnelUpdateWithWhereUniqueWithoutIn_node_groupInput>;
+export declare const TunnelUpdateManyWithWhereWithoutIn_node_groupInputSchema: z.ZodType<Prisma.TunnelUpdateManyWithWhereWithoutIn_node_groupInput>;
+export declare const TunnelScalarWhereInputSchema: z.ZodType<Prisma.TunnelScalarWhereInput>;
+export declare const TunnelUpsertWithWhereUniqueWithoutOut_node_groupInputSchema: z.ZodType<Prisma.TunnelUpsertWithWhereUniqueWithoutOut_node_groupInput>;
+export declare const TunnelUpdateWithWhereUniqueWithoutOut_node_groupInputSchema: z.ZodType<Prisma.TunnelUpdateWithWhereUniqueWithoutOut_node_groupInput>;
+export declare const TunnelUpdateManyWithWhereWithoutOut_node_groupInputSchema: z.ZodType<Prisma.TunnelUpdateManyWithWhereWithoutOut_node_groupInput>;
+export declare const NodeUpsertWithWhereUniqueWithoutNode_groupInputSchema: z.ZodType<Prisma.NodeUpsertWithWhereUniqueWithoutNode_groupInput>;
+export declare const NodeUpdateWithWhereUniqueWithoutNode_groupInputSchema: z.ZodType<Prisma.NodeUpdateWithWhereUniqueWithoutNode_groupInput>;
+export declare const NodeUpdateManyWithWhereWithoutNode_groupInputSchema: z.ZodType<Prisma.NodeUpdateManyWithWhereWithoutNode_groupInput>;
+export declare const NodeScalarWhereInputSchema: z.ZodType<Prisma.NodeScalarWhereInput>;
+export declare const PlanNodeGroupUpsertWithWhereUniqueWithoutNode_groupInputSchema: z.ZodType<Prisma.PlanNodeGroupUpsertWithWhereUniqueWithoutNode_groupInput>;
+export declare const PlanNodeGroupUpdateWithWhereUniqueWithoutNode_groupInputSchema: z.ZodType<Prisma.PlanNodeGroupUpdateWithWhereUniqueWithoutNode_groupInput>;
+export declare const PlanNodeGroupUpdateManyWithWhereWithoutNode_groupInputSchema: z.ZodType<Prisma.PlanNodeGroupUpdateManyWithWhereWithoutNode_groupInput>;
+export declare const PlanNodeGroupScalarWhereInputSchema: z.ZodType<Prisma.PlanNodeGroupScalarWhereInput>;
+export declare const TunnelChainUpsertWithWhereUniqueWithoutNode_groupInputSchema: z.ZodType<Prisma.TunnelChainUpsertWithWhereUniqueWithoutNode_groupInput>;
+export declare const TunnelChainUpdateWithWhereUniqueWithoutNode_groupInputSchema: z.ZodType<Prisma.TunnelChainUpdateWithWhereUniqueWithoutNode_groupInput>;
+export declare const TunnelChainUpdateManyWithWhereWithoutNode_groupInputSchema: z.ZodType<Prisma.TunnelChainUpdateManyWithWhereWithoutNode_groupInput>;
+export declare const TunnelChainScalarWhereInputSchema: z.ZodType<Prisma.TunnelChainScalarWhereInput>;
+export declare const InNodeGroupDNSUpsertWithWhereUniqueWithoutIn_node_groupInputSchema: z.ZodType<Prisma.InNodeGroupDNSUpsertWithWhereUniqueWithoutIn_node_groupInput>;
+export declare const InNodeGroupDNSUpdateWithWhereUniqueWithoutIn_node_groupInputSchema: z.ZodType<Prisma.InNodeGroupDNSUpdateWithWhereUniqueWithoutIn_node_groupInput>;
+export declare const InNodeGroupDNSUpdateManyWithWhereWithoutIn_node_groupInputSchema: z.ZodType<Prisma.InNodeGroupDNSUpdateManyWithWhereWithoutIn_node_groupInput>;
+export declare const InNodeGroupDNSScalarWhereInputSchema: z.ZodType<Prisma.InNodeGroupDNSScalarWhereInput>;
+export declare const NodeGroupCreateWithoutNodesInputSchema: z.ZodType<Prisma.NodeGroupCreateWithoutNodesInput>;
+export declare const NodeGroupUncheckedCreateWithoutNodesInputSchema: z.ZodType<Prisma.NodeGroupUncheckedCreateWithoutNodesInput>;
+export declare const NodeGroupCreateOrConnectWithoutNodesInputSchema: z.ZodType<Prisma.NodeGroupCreateOrConnectWithoutNodesInput>;
+export declare const NodeGroupUpsertWithoutNodesInputSchema: z.ZodType<Prisma.NodeGroupUpsertWithoutNodesInput>;
+export declare const NodeGroupUpdateToOneWithWhereWithoutNodesInputSchema: z.ZodType<Prisma.NodeGroupUpdateToOneWithWhereWithoutNodesInput>;
+export declare const NodeGroupUpdateWithoutNodesInputSchema: z.ZodType<Prisma.NodeGroupUpdateWithoutNodesInput>;
+export declare const NodeGroupUncheckedUpdateWithoutNodesInputSchema: z.ZodType<Prisma.NodeGroupUncheckedUpdateWithoutNodesInput>;
+export declare const NodeGroupCreateWithoutIn_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupCreateWithoutIn_tunnelsInput>;
+export declare const NodeGroupUncheckedCreateWithoutIn_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupUncheckedCreateWithoutIn_tunnelsInput>;
+export declare const NodeGroupCreateOrConnectWithoutIn_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupCreateOrConnectWithoutIn_tunnelsInput>;
+export declare const NodeGroupCreateWithoutOut_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupCreateWithoutOut_tunnelsInput>;
+export declare const NodeGroupUncheckedCreateWithoutOut_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupUncheckedCreateWithoutOut_tunnelsInput>;
+export declare const NodeGroupCreateOrConnectWithoutOut_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupCreateOrConnectWithoutOut_tunnelsInput>;
+export declare const UserCreateWithoutTunnelsInputSchema: z.ZodType<Prisma.UserCreateWithoutTunnelsInput>;
+export declare const UserUncheckedCreateWithoutTunnelsInputSchema: z.ZodType<Prisma.UserUncheckedCreateWithoutTunnelsInput>;
+export declare const UserCreateOrConnectWithoutTunnelsInputSchema: z.ZodType<Prisma.UserCreateOrConnectWithoutTunnelsInput>;
+export declare const TunnelTrafficCreateWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelTrafficCreateWithoutTunnelInput>;
+export declare const TunnelTrafficUncheckedCreateWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelTrafficUncheckedCreateWithoutTunnelInput>;
+export declare const TunnelTrafficCreateOrConnectWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelTrafficCreateOrConnectWithoutTunnelInput>;
+export declare const TunnelTrafficCreateManyTunnelInputEnvelopeSchema: z.ZodType<Prisma.TunnelTrafficCreateManyTunnelInputEnvelope>;
+export declare const TunnelChainCreateWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelChainCreateWithoutTunnelInput>;
+export declare const TunnelChainUncheckedCreateWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelChainUncheckedCreateWithoutTunnelInput>;
+export declare const TunnelChainCreateOrConnectWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelChainCreateOrConnectWithoutTunnelInput>;
+export declare const TunnelChainCreateManyTunnelInputEnvelopeSchema: z.ZodType<Prisma.TunnelChainCreateManyTunnelInputEnvelope>;
+export declare const NodeGroupUpsertWithoutIn_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupUpsertWithoutIn_tunnelsInput>;
+export declare const NodeGroupUpdateToOneWithWhereWithoutIn_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupUpdateToOneWithWhereWithoutIn_tunnelsInput>;
+export declare const NodeGroupUpdateWithoutIn_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupUpdateWithoutIn_tunnelsInput>;
+export declare const NodeGroupUncheckedUpdateWithoutIn_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupUncheckedUpdateWithoutIn_tunnelsInput>;
+export declare const NodeGroupUpsertWithoutOut_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupUpsertWithoutOut_tunnelsInput>;
+export declare const NodeGroupUpdateToOneWithWhereWithoutOut_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupUpdateToOneWithWhereWithoutOut_tunnelsInput>;
+export declare const NodeGroupUpdateWithoutOut_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupUpdateWithoutOut_tunnelsInput>;
+export declare const NodeGroupUncheckedUpdateWithoutOut_tunnelsInputSchema: z.ZodType<Prisma.NodeGroupUncheckedUpdateWithoutOut_tunnelsInput>;
+export declare const UserUpsertWithoutTunnelsInputSchema: z.ZodType<Prisma.UserUpsertWithoutTunnelsInput>;
+export declare const UserUpdateToOneWithWhereWithoutTunnelsInputSchema: z.ZodType<Prisma.UserUpdateToOneWithWhereWithoutTunnelsInput>;
+export declare const UserUpdateWithoutTunnelsInputSchema: z.ZodType<Prisma.UserUpdateWithoutTunnelsInput>;
+export declare const UserUncheckedUpdateWithoutTunnelsInputSchema: z.ZodType<Prisma.UserUncheckedUpdateWithoutTunnelsInput>;
+export declare const TunnelTrafficUpsertWithWhereUniqueWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelTrafficUpsertWithWhereUniqueWithoutTunnelInput>;
+export declare const TunnelTrafficUpdateWithWhereUniqueWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelTrafficUpdateWithWhereUniqueWithoutTunnelInput>;
+export declare const TunnelTrafficUpdateManyWithWhereWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelTrafficUpdateManyWithWhereWithoutTunnelInput>;
+export declare const TunnelTrafficScalarWhereInputSchema: z.ZodType<Prisma.TunnelTrafficScalarWhereInput>;
+export declare const TunnelChainUpsertWithWhereUniqueWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelChainUpsertWithWhereUniqueWithoutTunnelInput>;
+export declare const TunnelChainUpdateWithWhereUniqueWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelChainUpdateWithWhereUniqueWithoutTunnelInput>;
+export declare const TunnelChainUpdateManyWithWhereWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelChainUpdateManyWithWhereWithoutTunnelInput>;
+export declare const TunnelCreateWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.TunnelCreateWithoutTunnel_chainsInput>;
+export declare const TunnelUncheckedCreateWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.TunnelUncheckedCreateWithoutTunnel_chainsInput>;
+export declare const TunnelCreateOrConnectWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.TunnelCreateOrConnectWithoutTunnel_chainsInput>;
+export declare const NodeGroupCreateWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.NodeGroupCreateWithoutTunnel_chainsInput>;
+export declare const NodeGroupUncheckedCreateWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.NodeGroupUncheckedCreateWithoutTunnel_chainsInput>;
+export declare const NodeGroupCreateOrConnectWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.NodeGroupCreateOrConnectWithoutTunnel_chainsInput>;
+export declare const TunnelUpsertWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.TunnelUpsertWithoutTunnel_chainsInput>;
+export declare const TunnelUpdateToOneWithWhereWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.TunnelUpdateToOneWithWhereWithoutTunnel_chainsInput>;
+export declare const TunnelUpdateWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.TunnelUpdateWithoutTunnel_chainsInput>;
+export declare const TunnelUncheckedUpdateWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.TunnelUncheckedUpdateWithoutTunnel_chainsInput>;
+export declare const NodeGroupUpsertWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.NodeGroupUpsertWithoutTunnel_chainsInput>;
+export declare const NodeGroupUpdateToOneWithWhereWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.NodeGroupUpdateToOneWithWhereWithoutTunnel_chainsInput>;
+export declare const NodeGroupUpdateWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.NodeGroupUpdateWithoutTunnel_chainsInput>;
+export declare const NodeGroupUncheckedUpdateWithoutTunnel_chainsInputSchema: z.ZodType<Prisma.NodeGroupUncheckedUpdateWithoutTunnel_chainsInput>;
+export declare const TunnelCreateWithoutUserInputSchema: z.ZodType<Prisma.TunnelCreateWithoutUserInput>;
+export declare const TunnelUncheckedCreateWithoutUserInputSchema: z.ZodType<Prisma.TunnelUncheckedCreateWithoutUserInput>;
+export declare const TunnelCreateOrConnectWithoutUserInputSchema: z.ZodType<Prisma.TunnelCreateOrConnectWithoutUserInput>;
+export declare const TunnelCreateManyUserInputEnvelopeSchema: z.ZodType<Prisma.TunnelCreateManyUserInputEnvelope>;
+export declare const UserCreateWithoutChildrenInputSchema: z.ZodType<Prisma.UserCreateWithoutChildrenInput>;
+export declare const UserUncheckedCreateWithoutChildrenInputSchema: z.ZodType<Prisma.UserUncheckedCreateWithoutChildrenInput>;
+export declare const UserCreateOrConnectWithoutChildrenInputSchema: z.ZodType<Prisma.UserCreateOrConnectWithoutChildrenInput>;
+export declare const UserCreateWithoutParentInputSchema: z.ZodType<Prisma.UserCreateWithoutParentInput>;
+export declare const UserUncheckedCreateWithoutParentInputSchema: z.ZodType<Prisma.UserUncheckedCreateWithoutParentInput>;
+export declare const UserCreateOrConnectWithoutParentInputSchema: z.ZodType<Prisma.UserCreateOrConnectWithoutParentInput>;
+export declare const UserCreateManyParentInputEnvelopeSchema: z.ZodType<Prisma.UserCreateManyParentInputEnvelope>;
+export declare const NodeGroupCreateWithoutUserInputSchema: z.ZodType<Prisma.NodeGroupCreateWithoutUserInput>;
+export declare const NodeGroupUncheckedCreateWithoutUserInputSchema: z.ZodType<Prisma.NodeGroupUncheckedCreateWithoutUserInput>;
+export declare const NodeGroupCreateOrConnectWithoutUserInputSchema: z.ZodType<Prisma.NodeGroupCreateOrConnectWithoutUserInput>;
+export declare const NodeGroupCreateManyUserInputEnvelopeSchema: z.ZodType<Prisma.NodeGroupCreateManyUserInputEnvelope>;
+export declare const PlanOrderCreateWithoutUserInputSchema: z.ZodType<Prisma.PlanOrderCreateWithoutUserInput>;
+export declare const PlanOrderUncheckedCreateWithoutUserInputSchema: z.ZodType<Prisma.PlanOrderUncheckedCreateWithoutUserInput>;
+export declare const PlanOrderCreateOrConnectWithoutUserInputSchema: z.ZodType<Prisma.PlanOrderCreateOrConnectWithoutUserInput>;
+export declare const PlanOrderCreateManyUserInputEnvelopeSchema: z.ZodType<Prisma.PlanOrderCreateManyUserInputEnvelope>;
+export declare const TopupOrderCreateWithoutUserInputSchema: z.ZodType<Prisma.TopupOrderCreateWithoutUserInput>;
+export declare const TopupOrderUncheckedCreateWithoutUserInputSchema: z.ZodType<Prisma.TopupOrderUncheckedCreateWithoutUserInput>;
+export declare const TopupOrderCreateOrConnectWithoutUserInputSchema: z.ZodType<Prisma.TopupOrderCreateOrConnectWithoutUserInput>;
+export declare const TopupOrderCreateManyUserInputEnvelopeSchema: z.ZodType<Prisma.TopupOrderCreateManyUserInputEnvelope>;
+export declare const UserPlanCreateWithoutUserInputSchema: z.ZodType<Prisma.UserPlanCreateWithoutUserInput>;
+export declare const UserPlanUncheckedCreateWithoutUserInputSchema: z.ZodType<Prisma.UserPlanUncheckedCreateWithoutUserInput>;
+export declare const UserPlanCreateOrConnectWithoutUserInputSchema: z.ZodType<Prisma.UserPlanCreateOrConnectWithoutUserInput>;
+export declare const BalanceLogCreateWithoutUserInputSchema: z.ZodType<Prisma.BalanceLogCreateWithoutUserInput>;
+export declare const BalanceLogUncheckedCreateWithoutUserInputSchema: z.ZodType<Prisma.BalanceLogUncheckedCreateWithoutUserInput>;
+export declare const BalanceLogCreateOrConnectWithoutUserInputSchema: z.ZodType<Prisma.BalanceLogCreateOrConnectWithoutUserInput>;
+export declare const BalanceLogCreateManyUserInputEnvelopeSchema: z.ZodType<Prisma.BalanceLogCreateManyUserInputEnvelope>;
+export declare const TicketCreateWithoutUserInputSchema: z.ZodType<Prisma.TicketCreateWithoutUserInput>;
+export declare const TicketUncheckedCreateWithoutUserInputSchema: z.ZodType<Prisma.TicketUncheckedCreateWithoutUserInput>;
+export declare const TicketCreateOrConnectWithoutUserInputSchema: z.ZodType<Prisma.TicketCreateOrConnectWithoutUserInput>;
+export declare const TicketCreateManyUserInputEnvelopeSchema: z.ZodType<Prisma.TicketCreateManyUserInputEnvelope>;
+export declare const TicketReplyCreateWithoutUserInputSchema: z.ZodType<Prisma.TicketReplyCreateWithoutUserInput>;
+export declare const TicketReplyUncheckedCreateWithoutUserInputSchema: z.ZodType<Prisma.TicketReplyUncheckedCreateWithoutUserInput>;
+export declare const TicketReplyCreateOrConnectWithoutUserInputSchema: z.ZodType<Prisma.TicketReplyCreateOrConnectWithoutUserInput>;
+export declare const TicketReplyCreateManyUserInputEnvelopeSchema: z.ZodType<Prisma.TicketReplyCreateManyUserInputEnvelope>;
+export declare const TunnelUpsertWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.TunnelUpsertWithWhereUniqueWithoutUserInput>;
+export declare const TunnelUpdateWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.TunnelUpdateWithWhereUniqueWithoutUserInput>;
+export declare const TunnelUpdateManyWithWhereWithoutUserInputSchema: z.ZodType<Prisma.TunnelUpdateManyWithWhereWithoutUserInput>;
+export declare const UserUpsertWithoutChildrenInputSchema: z.ZodType<Prisma.UserUpsertWithoutChildrenInput>;
+export declare const UserUpdateToOneWithWhereWithoutChildrenInputSchema: z.ZodType<Prisma.UserUpdateToOneWithWhereWithoutChildrenInput>;
+export declare const UserUpdateWithoutChildrenInputSchema: z.ZodType<Prisma.UserUpdateWithoutChildrenInput>;
+export declare const UserUncheckedUpdateWithoutChildrenInputSchema: z.ZodType<Prisma.UserUncheckedUpdateWithoutChildrenInput>;
+export declare const UserUpsertWithWhereUniqueWithoutParentInputSchema: z.ZodType<Prisma.UserUpsertWithWhereUniqueWithoutParentInput>;
+export declare const UserUpdateWithWhereUniqueWithoutParentInputSchema: z.ZodType<Prisma.UserUpdateWithWhereUniqueWithoutParentInput>;
+export declare const UserUpdateManyWithWhereWithoutParentInputSchema: z.ZodType<Prisma.UserUpdateManyWithWhereWithoutParentInput>;
+export declare const UserScalarWhereInputSchema: z.ZodType<Prisma.UserScalarWhereInput>;
+export declare const NodeGroupUpsertWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.NodeGroupUpsertWithWhereUniqueWithoutUserInput>;
+export declare const NodeGroupUpdateWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.NodeGroupUpdateWithWhereUniqueWithoutUserInput>;
+export declare const NodeGroupUpdateManyWithWhereWithoutUserInputSchema: z.ZodType<Prisma.NodeGroupUpdateManyWithWhereWithoutUserInput>;
+export declare const NodeGroupScalarWhereInputSchema: z.ZodType<Prisma.NodeGroupScalarWhereInput>;
+export declare const PlanOrderUpsertWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.PlanOrderUpsertWithWhereUniqueWithoutUserInput>;
+export declare const PlanOrderUpdateWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.PlanOrderUpdateWithWhereUniqueWithoutUserInput>;
+export declare const PlanOrderUpdateManyWithWhereWithoutUserInputSchema: z.ZodType<Prisma.PlanOrderUpdateManyWithWhereWithoutUserInput>;
+export declare const PlanOrderScalarWhereInputSchema: z.ZodType<Prisma.PlanOrderScalarWhereInput>;
+export declare const TopupOrderUpsertWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.TopupOrderUpsertWithWhereUniqueWithoutUserInput>;
+export declare const TopupOrderUpdateWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.TopupOrderUpdateWithWhereUniqueWithoutUserInput>;
+export declare const TopupOrderUpdateManyWithWhereWithoutUserInputSchema: z.ZodType<Prisma.TopupOrderUpdateManyWithWhereWithoutUserInput>;
+export declare const TopupOrderScalarWhereInputSchema: z.ZodType<Prisma.TopupOrderScalarWhereInput>;
+export declare const UserPlanUpsertWithoutUserInputSchema: z.ZodType<Prisma.UserPlanUpsertWithoutUserInput>;
+export declare const UserPlanUpdateToOneWithWhereWithoutUserInputSchema: z.ZodType<Prisma.UserPlanUpdateToOneWithWhereWithoutUserInput>;
+export declare const UserPlanUpdateWithoutUserInputSchema: z.ZodType<Prisma.UserPlanUpdateWithoutUserInput>;
+export declare const UserPlanUncheckedUpdateWithoutUserInputSchema: z.ZodType<Prisma.UserPlanUncheckedUpdateWithoutUserInput>;
+export declare const BalanceLogUpsertWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.BalanceLogUpsertWithWhereUniqueWithoutUserInput>;
+export declare const BalanceLogUpdateWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.BalanceLogUpdateWithWhereUniqueWithoutUserInput>;
+export declare const BalanceLogUpdateManyWithWhereWithoutUserInputSchema: z.ZodType<Prisma.BalanceLogUpdateManyWithWhereWithoutUserInput>;
+export declare const BalanceLogScalarWhereInputSchema: z.ZodType<Prisma.BalanceLogScalarWhereInput>;
+export declare const TicketUpsertWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.TicketUpsertWithWhereUniqueWithoutUserInput>;
+export declare const TicketUpdateWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.TicketUpdateWithWhereUniqueWithoutUserInput>;
+export declare const TicketUpdateManyWithWhereWithoutUserInputSchema: z.ZodType<Prisma.TicketUpdateManyWithWhereWithoutUserInput>;
+export declare const TicketScalarWhereInputSchema: z.ZodType<Prisma.TicketScalarWhereInput>;
+export declare const TicketReplyUpsertWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.TicketReplyUpsertWithWhereUniqueWithoutUserInput>;
+export declare const TicketReplyUpdateWithWhereUniqueWithoutUserInputSchema: z.ZodType<Prisma.TicketReplyUpdateWithWhereUniqueWithoutUserInput>;
+export declare const TicketReplyUpdateManyWithWhereWithoutUserInputSchema: z.ZodType<Prisma.TicketReplyUpdateManyWithWhereWithoutUserInput>;
+export declare const TicketReplyScalarWhereInputSchema: z.ZodType<Prisma.TicketReplyScalarWhereInput>;
+export declare const UserCreateWithoutUser_planInputSchema: z.ZodType<Prisma.UserCreateWithoutUser_planInput>;
+export declare const UserUncheckedCreateWithoutUser_planInputSchema: z.ZodType<Prisma.UserUncheckedCreateWithoutUser_planInput>;
+export declare const UserCreateOrConnectWithoutUser_planInputSchema: z.ZodType<Prisma.UserCreateOrConnectWithoutUser_planInput>;
+export declare const PlanCreateWithoutUser_plansInputSchema: z.ZodType<Prisma.PlanCreateWithoutUser_plansInput>;
+export declare const PlanUncheckedCreateWithoutUser_plansInputSchema: z.ZodType<Prisma.PlanUncheckedCreateWithoutUser_plansInput>;
+export declare const PlanCreateOrConnectWithoutUser_plansInputSchema: z.ZodType<Prisma.PlanCreateOrConnectWithoutUser_plansInput>;
+export declare const UserUpsertWithoutUser_planInputSchema: z.ZodType<Prisma.UserUpsertWithoutUser_planInput>;
+export declare const UserUpdateToOneWithWhereWithoutUser_planInputSchema: z.ZodType<Prisma.UserUpdateToOneWithWhereWithoutUser_planInput>;
+export declare const UserUpdateWithoutUser_planInputSchema: z.ZodType<Prisma.UserUpdateWithoutUser_planInput>;
+export declare const UserUncheckedUpdateWithoutUser_planInputSchema: z.ZodType<Prisma.UserUncheckedUpdateWithoutUser_planInput>;
+export declare const PlanUpsertWithoutUser_plansInputSchema: z.ZodType<Prisma.PlanUpsertWithoutUser_plansInput>;
+export declare const PlanUpdateToOneWithWhereWithoutUser_plansInputSchema: z.ZodType<Prisma.PlanUpdateToOneWithWhereWithoutUser_plansInput>;
+export declare const PlanUpdateWithoutUser_plansInputSchema: z.ZodType<Prisma.PlanUpdateWithoutUser_plansInput>;
+export declare const PlanUncheckedUpdateWithoutUser_plansInputSchema: z.ZodType<Prisma.PlanUncheckedUpdateWithoutUser_plansInput>;
+export declare const PlanNodeGroupCreateWithoutPlanInputSchema: z.ZodType<Prisma.PlanNodeGroupCreateWithoutPlanInput>;
+export declare const PlanNodeGroupUncheckedCreateWithoutPlanInputSchema: z.ZodType<Prisma.PlanNodeGroupUncheckedCreateWithoutPlanInput>;
+export declare const PlanNodeGroupCreateOrConnectWithoutPlanInputSchema: z.ZodType<Prisma.PlanNodeGroupCreateOrConnectWithoutPlanInput>;
+export declare const PlanNodeGroupCreateManyPlanInputEnvelopeSchema: z.ZodType<Prisma.PlanNodeGroupCreateManyPlanInputEnvelope>;
+export declare const PlanOrderCreateWithoutPlanInputSchema: z.ZodType<Prisma.PlanOrderCreateWithoutPlanInput>;
+export declare const PlanOrderUncheckedCreateWithoutPlanInputSchema: z.ZodType<Prisma.PlanOrderUncheckedCreateWithoutPlanInput>;
+export declare const PlanOrderCreateOrConnectWithoutPlanInputSchema: z.ZodType<Prisma.PlanOrderCreateOrConnectWithoutPlanInput>;
+export declare const PlanOrderCreateManyPlanInputEnvelopeSchema: z.ZodType<Prisma.PlanOrderCreateManyPlanInputEnvelope>;
+export declare const UserPlanCreateWithoutPlanInputSchema: z.ZodType<Prisma.UserPlanCreateWithoutPlanInput>;
+export declare const UserPlanUncheckedCreateWithoutPlanInputSchema: z.ZodType<Prisma.UserPlanUncheckedCreateWithoutPlanInput>;
+export declare const UserPlanCreateOrConnectWithoutPlanInputSchema: z.ZodType<Prisma.UserPlanCreateOrConnectWithoutPlanInput>;
+export declare const UserPlanCreateManyPlanInputEnvelopeSchema: z.ZodType<Prisma.UserPlanCreateManyPlanInputEnvelope>;
+export declare const PlanNodeGroupUpsertWithWhereUniqueWithoutPlanInputSchema: z.ZodType<Prisma.PlanNodeGroupUpsertWithWhereUniqueWithoutPlanInput>;
+export declare const PlanNodeGroupUpdateWithWhereUniqueWithoutPlanInputSchema: z.ZodType<Prisma.PlanNodeGroupUpdateWithWhereUniqueWithoutPlanInput>;
+export declare const PlanNodeGroupUpdateManyWithWhereWithoutPlanInputSchema: z.ZodType<Prisma.PlanNodeGroupUpdateManyWithWhereWithoutPlanInput>;
+export declare const PlanOrderUpsertWithWhereUniqueWithoutPlanInputSchema: z.ZodType<Prisma.PlanOrderUpsertWithWhereUniqueWithoutPlanInput>;
+export declare const PlanOrderUpdateWithWhereUniqueWithoutPlanInputSchema: z.ZodType<Prisma.PlanOrderUpdateWithWhereUniqueWithoutPlanInput>;
+export declare const PlanOrderUpdateManyWithWhereWithoutPlanInputSchema: z.ZodType<Prisma.PlanOrderUpdateManyWithWhereWithoutPlanInput>;
+export declare const UserPlanUpsertWithWhereUniqueWithoutPlanInputSchema: z.ZodType<Prisma.UserPlanUpsertWithWhereUniqueWithoutPlanInput>;
+export declare const UserPlanUpdateWithWhereUniqueWithoutPlanInputSchema: z.ZodType<Prisma.UserPlanUpdateWithWhereUniqueWithoutPlanInput>;
+export declare const UserPlanUpdateManyWithWhereWithoutPlanInputSchema: z.ZodType<Prisma.UserPlanUpdateManyWithWhereWithoutPlanInput>;
+export declare const UserPlanScalarWhereInputSchema: z.ZodType<Prisma.UserPlanScalarWhereInput>;
+export declare const NodeGroupCreateWithoutPlansInputSchema: z.ZodType<Prisma.NodeGroupCreateWithoutPlansInput>;
+export declare const NodeGroupUncheckedCreateWithoutPlansInputSchema: z.ZodType<Prisma.NodeGroupUncheckedCreateWithoutPlansInput>;
+export declare const NodeGroupCreateOrConnectWithoutPlansInputSchema: z.ZodType<Prisma.NodeGroupCreateOrConnectWithoutPlansInput>;
+export declare const PlanCreateWithoutNode_groupsInputSchema: z.ZodType<Prisma.PlanCreateWithoutNode_groupsInput>;
+export declare const PlanUncheckedCreateWithoutNode_groupsInputSchema: z.ZodType<Prisma.PlanUncheckedCreateWithoutNode_groupsInput>;
+export declare const PlanCreateOrConnectWithoutNode_groupsInputSchema: z.ZodType<Prisma.PlanCreateOrConnectWithoutNode_groupsInput>;
+export declare const NodeGroupUpsertWithoutPlansInputSchema: z.ZodType<Prisma.NodeGroupUpsertWithoutPlansInput>;
+export declare const NodeGroupUpdateToOneWithWhereWithoutPlansInputSchema: z.ZodType<Prisma.NodeGroupUpdateToOneWithWhereWithoutPlansInput>;
+export declare const NodeGroupUpdateWithoutPlansInputSchema: z.ZodType<Prisma.NodeGroupUpdateWithoutPlansInput>;
+export declare const NodeGroupUncheckedUpdateWithoutPlansInputSchema: z.ZodType<Prisma.NodeGroupUncheckedUpdateWithoutPlansInput>;
+export declare const PlanUpsertWithoutNode_groupsInputSchema: z.ZodType<Prisma.PlanUpsertWithoutNode_groupsInput>;
+export declare const PlanUpdateToOneWithWhereWithoutNode_groupsInputSchema: z.ZodType<Prisma.PlanUpdateToOneWithWhereWithoutNode_groupsInput>;
+export declare const PlanUpdateWithoutNode_groupsInputSchema: z.ZodType<Prisma.PlanUpdateWithoutNode_groupsInput>;
+export declare const PlanUncheckedUpdateWithoutNode_groupsInputSchema: z.ZodType<Prisma.PlanUncheckedUpdateWithoutNode_groupsInput>;
+export declare const UserCreateWithoutOrdersInputSchema: z.ZodType<Prisma.UserCreateWithoutOrdersInput>;
+export declare const UserUncheckedCreateWithoutOrdersInputSchema: z.ZodType<Prisma.UserUncheckedCreateWithoutOrdersInput>;
+export declare const UserCreateOrConnectWithoutOrdersInputSchema: z.ZodType<Prisma.UserCreateOrConnectWithoutOrdersInput>;
+export declare const PlanCreateWithoutOrdersInputSchema: z.ZodType<Prisma.PlanCreateWithoutOrdersInput>;
+export declare const PlanUncheckedCreateWithoutOrdersInputSchema: z.ZodType<Prisma.PlanUncheckedCreateWithoutOrdersInput>;
+export declare const PlanCreateOrConnectWithoutOrdersInputSchema: z.ZodType<Prisma.PlanCreateOrConnectWithoutOrdersInput>;
+export declare const PlanCouponCreateWithoutOrdersInputSchema: z.ZodType<Prisma.PlanCouponCreateWithoutOrdersInput>;
+export declare const PlanCouponUncheckedCreateWithoutOrdersInputSchema: z.ZodType<Prisma.PlanCouponUncheckedCreateWithoutOrdersInput>;
+export declare const PlanCouponCreateOrConnectWithoutOrdersInputSchema: z.ZodType<Prisma.PlanCouponCreateOrConnectWithoutOrdersInput>;
+export declare const UserUpsertWithoutOrdersInputSchema: z.ZodType<Prisma.UserUpsertWithoutOrdersInput>;
+export declare const UserUpdateToOneWithWhereWithoutOrdersInputSchema: z.ZodType<Prisma.UserUpdateToOneWithWhereWithoutOrdersInput>;
+export declare const UserUpdateWithoutOrdersInputSchema: z.ZodType<Prisma.UserUpdateWithoutOrdersInput>;
+export declare const UserUncheckedUpdateWithoutOrdersInputSchema: z.ZodType<Prisma.UserUncheckedUpdateWithoutOrdersInput>;
+export declare const PlanUpsertWithoutOrdersInputSchema: z.ZodType<Prisma.PlanUpsertWithoutOrdersInput>;
+export declare const PlanUpdateToOneWithWhereWithoutOrdersInputSchema: z.ZodType<Prisma.PlanUpdateToOneWithWhereWithoutOrdersInput>;
+export declare const PlanUpdateWithoutOrdersInputSchema: z.ZodType<Prisma.PlanUpdateWithoutOrdersInput>;
+export declare const PlanUncheckedUpdateWithoutOrdersInputSchema: z.ZodType<Prisma.PlanUncheckedUpdateWithoutOrdersInput>;
+export declare const PlanCouponUpsertWithoutOrdersInputSchema: z.ZodType<Prisma.PlanCouponUpsertWithoutOrdersInput>;
+export declare const PlanCouponUpdateToOneWithWhereWithoutOrdersInputSchema: z.ZodType<Prisma.PlanCouponUpdateToOneWithWhereWithoutOrdersInput>;
+export declare const PlanCouponUpdateWithoutOrdersInputSchema: z.ZodType<Prisma.PlanCouponUpdateWithoutOrdersInput>;
+export declare const PlanCouponUncheckedUpdateWithoutOrdersInputSchema: z.ZodType<Prisma.PlanCouponUncheckedUpdateWithoutOrdersInput>;
+export declare const UserCreateWithoutTopupsInputSchema: z.ZodType<Prisma.UserCreateWithoutTopupsInput>;
+export declare const UserUncheckedCreateWithoutTopupsInputSchema: z.ZodType<Prisma.UserUncheckedCreateWithoutTopupsInput>;
+export declare const UserCreateOrConnectWithoutTopupsInputSchema: z.ZodType<Prisma.UserCreateOrConnectWithoutTopupsInput>;
+export declare const PaymentCreateWithoutTopupsInputSchema: z.ZodType<Prisma.PaymentCreateWithoutTopupsInput>;
+export declare const PaymentUncheckedCreateWithoutTopupsInputSchema: z.ZodType<Prisma.PaymentUncheckedCreateWithoutTopupsInput>;
+export declare const PaymentCreateOrConnectWithoutTopupsInputSchema: z.ZodType<Prisma.PaymentCreateOrConnectWithoutTopupsInput>;
+export declare const UserUpsertWithoutTopupsInputSchema: z.ZodType<Prisma.UserUpsertWithoutTopupsInput>;
+export declare const UserUpdateToOneWithWhereWithoutTopupsInputSchema: z.ZodType<Prisma.UserUpdateToOneWithWhereWithoutTopupsInput>;
+export declare const UserUpdateWithoutTopupsInputSchema: z.ZodType<Prisma.UserUpdateWithoutTopupsInput>;
+export declare const UserUncheckedUpdateWithoutTopupsInputSchema: z.ZodType<Prisma.UserUncheckedUpdateWithoutTopupsInput>;
+export declare const PaymentUpsertWithoutTopupsInputSchema: z.ZodType<Prisma.PaymentUpsertWithoutTopupsInput>;
+export declare const PaymentUpdateToOneWithWhereWithoutTopupsInputSchema: z.ZodType<Prisma.PaymentUpdateToOneWithWhereWithoutTopupsInput>;
+export declare const PaymentUpdateWithoutTopupsInputSchema: z.ZodType<Prisma.PaymentUpdateWithoutTopupsInput>;
+export declare const PaymentUncheckedUpdateWithoutTopupsInputSchema: z.ZodType<Prisma.PaymentUncheckedUpdateWithoutTopupsInput>;
+export declare const TunnelCreateWithoutTunnel_trafficInputSchema: z.ZodType<Prisma.TunnelCreateWithoutTunnel_trafficInput>;
+export declare const TunnelUncheckedCreateWithoutTunnel_trafficInputSchema: z.ZodType<Prisma.TunnelUncheckedCreateWithoutTunnel_trafficInput>;
+export declare const TunnelCreateOrConnectWithoutTunnel_trafficInputSchema: z.ZodType<Prisma.TunnelCreateOrConnectWithoutTunnel_trafficInput>;
+export declare const TunnelUpsertWithoutTunnel_trafficInputSchema: z.ZodType<Prisma.TunnelUpsertWithoutTunnel_trafficInput>;
+export declare const TunnelUpdateToOneWithWhereWithoutTunnel_trafficInputSchema: z.ZodType<Prisma.TunnelUpdateToOneWithWhereWithoutTunnel_trafficInput>;
+export declare const TunnelUpdateWithoutTunnel_trafficInputSchema: z.ZodType<Prisma.TunnelUpdateWithoutTunnel_trafficInput>;
+export declare const TunnelUncheckedUpdateWithoutTunnel_trafficInputSchema: z.ZodType<Prisma.TunnelUncheckedUpdateWithoutTunnel_trafficInput>;
+export declare const TopupOrderCreateWithoutPaymentInputSchema: z.ZodType<Prisma.TopupOrderCreateWithoutPaymentInput>;
+export declare const TopupOrderUncheckedCreateWithoutPaymentInputSchema: z.ZodType<Prisma.TopupOrderUncheckedCreateWithoutPaymentInput>;
+export declare const TopupOrderCreateOrConnectWithoutPaymentInputSchema: z.ZodType<Prisma.TopupOrderCreateOrConnectWithoutPaymentInput>;
+export declare const TopupOrderCreateManyPaymentInputEnvelopeSchema: z.ZodType<Prisma.TopupOrderCreateManyPaymentInputEnvelope>;
+export declare const TopupOrderUpsertWithWhereUniqueWithoutPaymentInputSchema: z.ZodType<Prisma.TopupOrderUpsertWithWhereUniqueWithoutPaymentInput>;
+export declare const TopupOrderUpdateWithWhereUniqueWithoutPaymentInputSchema: z.ZodType<Prisma.TopupOrderUpdateWithWhereUniqueWithoutPaymentInput>;
+export declare const TopupOrderUpdateManyWithWhereWithoutPaymentInputSchema: z.ZodType<Prisma.TopupOrderUpdateManyWithWhereWithoutPaymentInput>;
+export declare const PlanOrderCreateWithoutCouponInputSchema: z.ZodType<Prisma.PlanOrderCreateWithoutCouponInput>;
+export declare const PlanOrderUncheckedCreateWithoutCouponInputSchema: z.ZodType<Prisma.PlanOrderUncheckedCreateWithoutCouponInput>;
+export declare const PlanOrderCreateOrConnectWithoutCouponInputSchema: z.ZodType<Prisma.PlanOrderCreateOrConnectWithoutCouponInput>;
+export declare const PlanOrderCreateManyCouponInputEnvelopeSchema: z.ZodType<Prisma.PlanOrderCreateManyCouponInputEnvelope>;
+export declare const PlanOrderUpsertWithWhereUniqueWithoutCouponInputSchema: z.ZodType<Prisma.PlanOrderUpsertWithWhereUniqueWithoutCouponInput>;
+export declare const PlanOrderUpdateWithWhereUniqueWithoutCouponInputSchema: z.ZodType<Prisma.PlanOrderUpdateWithWhereUniqueWithoutCouponInput>;
+export declare const PlanOrderUpdateManyWithWhereWithoutCouponInputSchema: z.ZodType<Prisma.PlanOrderUpdateManyWithWhereWithoutCouponInput>;
+export declare const UserCreateWithoutBalance_logsInputSchema: z.ZodType<Prisma.UserCreateWithoutBalance_logsInput>;
+export declare const UserUncheckedCreateWithoutBalance_logsInputSchema: z.ZodType<Prisma.UserUncheckedCreateWithoutBalance_logsInput>;
+export declare const UserCreateOrConnectWithoutBalance_logsInputSchema: z.ZodType<Prisma.UserCreateOrConnectWithoutBalance_logsInput>;
+export declare const UserUpsertWithoutBalance_logsInputSchema: z.ZodType<Prisma.UserUpsertWithoutBalance_logsInput>;
+export declare const UserUpdateToOneWithWhereWithoutBalance_logsInputSchema: z.ZodType<Prisma.UserUpdateToOneWithWhereWithoutBalance_logsInput>;
+export declare const UserUpdateWithoutBalance_logsInputSchema: z.ZodType<Prisma.UserUpdateWithoutBalance_logsInput>;
+export declare const UserUncheckedUpdateWithoutBalance_logsInputSchema: z.ZodType<Prisma.UserUncheckedUpdateWithoutBalance_logsInput>;
+export declare const UserCreateWithoutTicketsInputSchema: z.ZodType<Prisma.UserCreateWithoutTicketsInput>;
+export declare const UserUncheckedCreateWithoutTicketsInputSchema: z.ZodType<Prisma.UserUncheckedCreateWithoutTicketsInput>;
+export declare const UserCreateOrConnectWithoutTicketsInputSchema: z.ZodType<Prisma.UserCreateOrConnectWithoutTicketsInput>;
+export declare const TicketReplyCreateWithoutTicketInputSchema: z.ZodType<Prisma.TicketReplyCreateWithoutTicketInput>;
+export declare const TicketReplyUncheckedCreateWithoutTicketInputSchema: z.ZodType<Prisma.TicketReplyUncheckedCreateWithoutTicketInput>;
+export declare const TicketReplyCreateOrConnectWithoutTicketInputSchema: z.ZodType<Prisma.TicketReplyCreateOrConnectWithoutTicketInput>;
+export declare const TicketReplyCreateManyTicketInputEnvelopeSchema: z.ZodType<Prisma.TicketReplyCreateManyTicketInputEnvelope>;
+export declare const UserUpsertWithoutTicketsInputSchema: z.ZodType<Prisma.UserUpsertWithoutTicketsInput>;
+export declare const UserUpdateToOneWithWhereWithoutTicketsInputSchema: z.ZodType<Prisma.UserUpdateToOneWithWhereWithoutTicketsInput>;
+export declare const UserUpdateWithoutTicketsInputSchema: z.ZodType<Prisma.UserUpdateWithoutTicketsInput>;
+export declare const UserUncheckedUpdateWithoutTicketsInputSchema: z.ZodType<Prisma.UserUncheckedUpdateWithoutTicketsInput>;
+export declare const TicketReplyUpsertWithWhereUniqueWithoutTicketInputSchema: z.ZodType<Prisma.TicketReplyUpsertWithWhereUniqueWithoutTicketInput>;
+export declare const TicketReplyUpdateWithWhereUniqueWithoutTicketInputSchema: z.ZodType<Prisma.TicketReplyUpdateWithWhereUniqueWithoutTicketInput>;
+export declare const TicketReplyUpdateManyWithWhereWithoutTicketInputSchema: z.ZodType<Prisma.TicketReplyUpdateManyWithWhereWithoutTicketInput>;
+export declare const TicketCreateWithoutRepliesInputSchema: z.ZodType<Prisma.TicketCreateWithoutRepliesInput>;
+export declare const TicketUncheckedCreateWithoutRepliesInputSchema: z.ZodType<Prisma.TicketUncheckedCreateWithoutRepliesInput>;
+export declare const TicketCreateOrConnectWithoutRepliesInputSchema: z.ZodType<Prisma.TicketCreateOrConnectWithoutRepliesInput>;
+export declare const UserCreateWithoutTicket_repliesInputSchema: z.ZodType<Prisma.UserCreateWithoutTicket_repliesInput>;
+export declare const UserUncheckedCreateWithoutTicket_repliesInputSchema: z.ZodType<Prisma.UserUncheckedCreateWithoutTicket_repliesInput>;
+export declare const UserCreateOrConnectWithoutTicket_repliesInputSchema: z.ZodType<Prisma.UserCreateOrConnectWithoutTicket_repliesInput>;
+export declare const TicketUpsertWithoutRepliesInputSchema: z.ZodType<Prisma.TicketUpsertWithoutRepliesInput>;
+export declare const TicketUpdateToOneWithWhereWithoutRepliesInputSchema: z.ZodType<Prisma.TicketUpdateToOneWithWhereWithoutRepliesInput>;
+export declare const TicketUpdateWithoutRepliesInputSchema: z.ZodType<Prisma.TicketUpdateWithoutRepliesInput>;
+export declare const TicketUncheckedUpdateWithoutRepliesInputSchema: z.ZodType<Prisma.TicketUncheckedUpdateWithoutRepliesInput>;
+export declare const UserUpsertWithoutTicket_repliesInputSchema: z.ZodType<Prisma.UserUpsertWithoutTicket_repliesInput>;
+export declare const UserUpdateToOneWithWhereWithoutTicket_repliesInputSchema: z.ZodType<Prisma.UserUpdateToOneWithWhereWithoutTicket_repliesInput>;
+export declare const UserUpdateWithoutTicket_repliesInputSchema: z.ZodType<Prisma.UserUpdateWithoutTicket_repliesInput>;
+export declare const UserUncheckedUpdateWithoutTicket_repliesInputSchema: z.ZodType<Prisma.UserUncheckedUpdateWithoutTicket_repliesInput>;
+export declare const NodeGroupCreateWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.NodeGroupCreateWithoutIn_node_group_dnsInput>;
+export declare const NodeGroupUncheckedCreateWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.NodeGroupUncheckedCreateWithoutIn_node_group_dnsInput>;
+export declare const NodeGroupCreateOrConnectWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.NodeGroupCreateOrConnectWithoutIn_node_group_dnsInput>;
+export declare const DNSProviderCreateWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.DNSProviderCreateWithoutIn_node_group_dnsInput>;
+export declare const DNSProviderUncheckedCreateWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.DNSProviderUncheckedCreateWithoutIn_node_group_dnsInput>;
+export declare const DNSProviderCreateOrConnectWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.DNSProviderCreateOrConnectWithoutIn_node_group_dnsInput>;
+export declare const NodeGroupUpsertWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.NodeGroupUpsertWithoutIn_node_group_dnsInput>;
+export declare const NodeGroupUpdateToOneWithWhereWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.NodeGroupUpdateToOneWithWhereWithoutIn_node_group_dnsInput>;
+export declare const NodeGroupUpdateWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.NodeGroupUpdateWithoutIn_node_group_dnsInput>;
+export declare const NodeGroupUncheckedUpdateWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.NodeGroupUncheckedUpdateWithoutIn_node_group_dnsInput>;
+export declare const DNSProviderUpsertWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.DNSProviderUpsertWithoutIn_node_group_dnsInput>;
+export declare const DNSProviderUpdateToOneWithWhereWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.DNSProviderUpdateToOneWithWhereWithoutIn_node_group_dnsInput>;
+export declare const DNSProviderUpdateWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.DNSProviderUpdateWithoutIn_node_group_dnsInput>;
+export declare const DNSProviderUncheckedUpdateWithoutIn_node_group_dnsInputSchema: z.ZodType<Prisma.DNSProviderUncheckedUpdateWithoutIn_node_group_dnsInput>;
+export declare const InNodeGroupDNSCreateWithoutDns_providerInputSchema: z.ZodType<Prisma.InNodeGroupDNSCreateWithoutDns_providerInput>;
+export declare const InNodeGroupDNSUncheckedCreateWithoutDns_providerInputSchema: z.ZodType<Prisma.InNodeGroupDNSUncheckedCreateWithoutDns_providerInput>;
+export declare const InNodeGroupDNSCreateOrConnectWithoutDns_providerInputSchema: z.ZodType<Prisma.InNodeGroupDNSCreateOrConnectWithoutDns_providerInput>;
+export declare const InNodeGroupDNSCreateManyDns_providerInputEnvelopeSchema: z.ZodType<Prisma.InNodeGroupDNSCreateManyDns_providerInputEnvelope>;
+export declare const InNodeGroupDNSUpsertWithWhereUniqueWithoutDns_providerInputSchema: z.ZodType<Prisma.InNodeGroupDNSUpsertWithWhereUniqueWithoutDns_providerInput>;
+export declare const InNodeGroupDNSUpdateWithWhereUniqueWithoutDns_providerInputSchema: z.ZodType<Prisma.InNodeGroupDNSUpdateWithWhereUniqueWithoutDns_providerInput>;
+export declare const InNodeGroupDNSUpdateManyWithWhereWithoutDns_providerInputSchema: z.ZodType<Prisma.InNodeGroupDNSUpdateManyWithWhereWithoutDns_providerInput>;
+export declare const TunnelCreateManyIn_node_groupInputSchema: z.ZodType<Prisma.TunnelCreateManyIn_node_groupInput>;
+export declare const TunnelCreateManyOut_node_groupInputSchema: z.ZodType<Prisma.TunnelCreateManyOut_node_groupInput>;
+export declare const NodeCreateManyNode_groupInputSchema: z.ZodType<Prisma.NodeCreateManyNode_groupInput>;
+export declare const PlanNodeGroupCreateManyNode_groupInputSchema: z.ZodType<Prisma.PlanNodeGroupCreateManyNode_groupInput>;
+export declare const TunnelChainCreateManyNode_groupInputSchema: z.ZodType<Prisma.TunnelChainCreateManyNode_groupInput>;
+export declare const InNodeGroupDNSCreateManyIn_node_groupInputSchema: z.ZodType<Prisma.InNodeGroupDNSCreateManyIn_node_groupInput>;
+export declare const TunnelUpdateWithoutIn_node_groupInputSchema: z.ZodType<Prisma.TunnelUpdateWithoutIn_node_groupInput>;
+export declare const TunnelUncheckedUpdateWithoutIn_node_groupInputSchema: z.ZodType<Prisma.TunnelUncheckedUpdateWithoutIn_node_groupInput>;
+export declare const TunnelUncheckedUpdateManyWithoutIn_node_groupInputSchema: z.ZodType<Prisma.TunnelUncheckedUpdateManyWithoutIn_node_groupInput>;
+export declare const TunnelUpdateWithoutOut_node_groupInputSchema: z.ZodType<Prisma.TunnelUpdateWithoutOut_node_groupInput>;
+export declare const TunnelUncheckedUpdateWithoutOut_node_groupInputSchema: z.ZodType<Prisma.TunnelUncheckedUpdateWithoutOut_node_groupInput>;
+export declare const TunnelUncheckedUpdateManyWithoutOut_node_groupInputSchema: z.ZodType<Prisma.TunnelUncheckedUpdateManyWithoutOut_node_groupInput>;
+export declare const NodeUpdateWithoutNode_groupInputSchema: z.ZodType<Prisma.NodeUpdateWithoutNode_groupInput>;
+export declare const NodeUncheckedUpdateWithoutNode_groupInputSchema: z.ZodType<Prisma.NodeUncheckedUpdateWithoutNode_groupInput>;
+export declare const NodeUncheckedUpdateManyWithoutNode_groupInputSchema: z.ZodType<Prisma.NodeUncheckedUpdateManyWithoutNode_groupInput>;
+export declare const PlanNodeGroupUpdateWithoutNode_groupInputSchema: z.ZodType<Prisma.PlanNodeGroupUpdateWithoutNode_groupInput>;
+export declare const PlanNodeGroupUncheckedUpdateWithoutNode_groupInputSchema: z.ZodType<Prisma.PlanNodeGroupUncheckedUpdateWithoutNode_groupInput>;
+export declare const PlanNodeGroupUncheckedUpdateManyWithoutNode_groupInputSchema: z.ZodType<Prisma.PlanNodeGroupUncheckedUpdateManyWithoutNode_groupInput>;
+export declare const TunnelChainUpdateWithoutNode_groupInputSchema: z.ZodType<Prisma.TunnelChainUpdateWithoutNode_groupInput>;
+export declare const TunnelChainUncheckedUpdateWithoutNode_groupInputSchema: z.ZodType<Prisma.TunnelChainUncheckedUpdateWithoutNode_groupInput>;
+export declare const TunnelChainUncheckedUpdateManyWithoutNode_groupInputSchema: z.ZodType<Prisma.TunnelChainUncheckedUpdateManyWithoutNode_groupInput>;
+export declare const InNodeGroupDNSUpdateWithoutIn_node_groupInputSchema: z.ZodType<Prisma.InNodeGroupDNSUpdateWithoutIn_node_groupInput>;
+export declare const InNodeGroupDNSUncheckedUpdateWithoutIn_node_groupInputSchema: z.ZodType<Prisma.InNodeGroupDNSUncheckedUpdateWithoutIn_node_groupInput>;
+export declare const InNodeGroupDNSUncheckedUpdateManyWithoutIn_node_groupInputSchema: z.ZodType<Prisma.InNodeGroupDNSUncheckedUpdateManyWithoutIn_node_groupInput>;
+export declare const TunnelTrafficCreateManyTunnelInputSchema: z.ZodType<Prisma.TunnelTrafficCreateManyTunnelInput>;
+export declare const TunnelChainCreateManyTunnelInputSchema: z.ZodType<Prisma.TunnelChainCreateManyTunnelInput>;
+export declare const TunnelTrafficUpdateWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelTrafficUpdateWithoutTunnelInput>;
+export declare const TunnelTrafficUncheckedUpdateWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelTrafficUncheckedUpdateWithoutTunnelInput>;
+export declare const TunnelTrafficUncheckedUpdateManyWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelTrafficUncheckedUpdateManyWithoutTunnelInput>;
+export declare const TunnelChainUpdateWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelChainUpdateWithoutTunnelInput>;
+export declare const TunnelChainUncheckedUpdateWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelChainUncheckedUpdateWithoutTunnelInput>;
+export declare const TunnelChainUncheckedUpdateManyWithoutTunnelInputSchema: z.ZodType<Prisma.TunnelChainUncheckedUpdateManyWithoutTunnelInput>;
+export declare const TunnelCreateManyUserInputSchema: z.ZodType<Prisma.TunnelCreateManyUserInput>;
+export declare const UserCreateManyParentInputSchema: z.ZodType<Prisma.UserCreateManyParentInput>;
+export declare const NodeGroupCreateManyUserInputSchema: z.ZodType<Prisma.NodeGroupCreateManyUserInput>;
+export declare const PlanOrderCreateManyUserInputSchema: z.ZodType<Prisma.PlanOrderCreateManyUserInput>;
+export declare const TopupOrderCreateManyUserInputSchema: z.ZodType<Prisma.TopupOrderCreateManyUserInput>;
+export declare const BalanceLogCreateManyUserInputSchema: z.ZodType<Prisma.BalanceLogCreateManyUserInput>;
+export declare const TicketCreateManyUserInputSchema: z.ZodType<Prisma.TicketCreateManyUserInput>;
+export declare const TicketReplyCreateManyUserInputSchema: z.ZodType<Prisma.TicketReplyCreateManyUserInput>;
+export declare const TunnelUpdateWithoutUserInputSchema: z.ZodType<Prisma.TunnelUpdateWithoutUserInput>;
+export declare const TunnelUncheckedUpdateWithoutUserInputSchema: z.ZodType<Prisma.TunnelUncheckedUpdateWithoutUserInput>;
+export declare const TunnelUncheckedUpdateManyWithoutUserInputSchema: z.ZodType<Prisma.TunnelUncheckedUpdateManyWithoutUserInput>;
+export declare const UserUpdateWithoutParentInputSchema: z.ZodType<Prisma.UserUpdateWithoutParentInput>;
+export declare const UserUncheckedUpdateWithoutParentInputSchema: z.ZodType<Prisma.UserUncheckedUpdateWithoutParentInput>;
+export declare const UserUncheckedUpdateManyWithoutParentInputSchema: z.ZodType<Prisma.UserUncheckedUpdateManyWithoutParentInput>;
+export declare const NodeGroupUpdateWithoutUserInputSchema: z.ZodType<Prisma.NodeGroupUpdateWithoutUserInput>;
+export declare const NodeGroupUncheckedUpdateWithoutUserInputSchema: z.ZodType<Prisma.NodeGroupUncheckedUpdateWithoutUserInput>;
+export declare const NodeGroupUncheckedUpdateManyWithoutUserInputSchema: z.ZodType<Prisma.NodeGroupUncheckedUpdateManyWithoutUserInput>;
+export declare const PlanOrderUpdateWithoutUserInputSchema: z.ZodType<Prisma.PlanOrderUpdateWithoutUserInput>;
+export declare const PlanOrderUncheckedUpdateWithoutUserInputSchema: z.ZodType<Prisma.PlanOrderUncheckedUpdateWithoutUserInput>;
+export declare const PlanOrderUncheckedUpdateManyWithoutUserInputSchema: z.ZodType<Prisma.PlanOrderUncheckedUpdateManyWithoutUserInput>;
+export declare const TopupOrderUpdateWithoutUserInputSchema: z.ZodType<Prisma.TopupOrderUpdateWithoutUserInput>;
+export declare const TopupOrderUncheckedUpdateWithoutUserInputSchema: z.ZodType<Prisma.TopupOrderUncheckedUpdateWithoutUserInput>;
+export declare const TopupOrderUncheckedUpdateManyWithoutUserInputSchema: z.ZodType<Prisma.TopupOrderUncheckedUpdateManyWithoutUserInput>;
+export declare const BalanceLogUpdateWithoutUserInputSchema: z.ZodType<Prisma.BalanceLogUpdateWithoutUserInput>;
+export declare const BalanceLogUncheckedUpdateWithoutUserInputSchema: z.ZodType<Prisma.BalanceLogUncheckedUpdateWithoutUserInput>;
+export declare const BalanceLogUncheckedUpdateManyWithoutUserInputSchema: z.ZodType<Prisma.BalanceLogUncheckedUpdateManyWithoutUserInput>;
+export declare const TicketUpdateWithoutUserInputSchema: z.ZodType<Prisma.TicketUpdateWithoutUserInput>;
+export declare const TicketUncheckedUpdateWithoutUserInputSchema: z.ZodType<Prisma.TicketUncheckedUpdateWithoutUserInput>;
+export declare const TicketUncheckedUpdateManyWithoutUserInputSchema: z.ZodType<Prisma.TicketUncheckedUpdateManyWithoutUserInput>;
+export declare const TicketReplyUpdateWithoutUserInputSchema: z.ZodType<Prisma.TicketReplyUpdateWithoutUserInput>;
+export declare const TicketReplyUncheckedUpdateWithoutUserInputSchema: z.ZodType<Prisma.TicketReplyUncheckedUpdateWithoutUserInput>;
+export declare const TicketReplyUncheckedUpdateManyWithoutUserInputSchema: z.ZodType<Prisma.TicketReplyUncheckedUpdateManyWithoutUserInput>;
+export declare const PlanNodeGroupCreateManyPlanInputSchema: z.ZodType<Prisma.PlanNodeGroupCreateManyPlanInput>;
+export declare const PlanOrderCreateManyPlanInputSchema: z.ZodType<Prisma.PlanOrderCreateManyPlanInput>;
+export declare const UserPlanCreateManyPlanInputSchema: z.ZodType<Prisma.UserPlanCreateManyPlanInput>;
+export declare const PlanNodeGroupUpdateWithoutPlanInputSchema: z.ZodType<Prisma.PlanNodeGroupUpdateWithoutPlanInput>;
+export declare const PlanNodeGroupUncheckedUpdateWithoutPlanInputSchema: z.ZodType<Prisma.PlanNodeGroupUncheckedUpdateWithoutPlanInput>;
+export declare const PlanNodeGroupUncheckedUpdateManyWithoutPlanInputSchema: z.ZodType<Prisma.PlanNodeGroupUncheckedUpdateManyWithoutPlanInput>;
+export declare const PlanOrderUpdateWithoutPlanInputSchema: z.ZodType<Prisma.PlanOrderUpdateWithoutPlanInput>;
+export declare const PlanOrderUncheckedUpdateWithoutPlanInputSchema: z.ZodType<Prisma.PlanOrderUncheckedUpdateWithoutPlanInput>;
+export declare const PlanOrderUncheckedUpdateManyWithoutPlanInputSchema: z.ZodType<Prisma.PlanOrderUncheckedUpdateManyWithoutPlanInput>;
+export declare const UserPlanUpdateWithoutPlanInputSchema: z.ZodType<Prisma.UserPlanUpdateWithoutPlanInput>;
+export declare const UserPlanUncheckedUpdateWithoutPlanInputSchema: z.ZodType<Prisma.UserPlanUncheckedUpdateWithoutPlanInput>;
+export declare const UserPlanUncheckedUpdateManyWithoutPlanInputSchema: z.ZodType<Prisma.UserPlanUncheckedUpdateManyWithoutPlanInput>;
+export declare const TopupOrderCreateManyPaymentInputSchema: z.ZodType<Prisma.TopupOrderCreateManyPaymentInput>;
+export declare const TopupOrderUpdateWithoutPaymentInputSchema: z.ZodType<Prisma.TopupOrderUpdateWithoutPaymentInput>;
+export declare const TopupOrderUncheckedUpdateWithoutPaymentInputSchema: z.ZodType<Prisma.TopupOrderUncheckedUpdateWithoutPaymentInput>;
+export declare const TopupOrderUncheckedUpdateManyWithoutPaymentInputSchema: z.ZodType<Prisma.TopupOrderUncheckedUpdateManyWithoutPaymentInput>;
+export declare const PlanOrderCreateManyCouponInputSchema: z.ZodType<Prisma.PlanOrderCreateManyCouponInput>;
+export declare const PlanOrderUpdateWithoutCouponInputSchema: z.ZodType<Prisma.PlanOrderUpdateWithoutCouponInput>;
+export declare const PlanOrderUncheckedUpdateWithoutCouponInputSchema: z.ZodType<Prisma.PlanOrderUncheckedUpdateWithoutCouponInput>;
+export declare const PlanOrderUncheckedUpdateManyWithoutCouponInputSchema: z.ZodType<Prisma.PlanOrderUncheckedUpdateManyWithoutCouponInput>;
+export declare const TicketReplyCreateManyTicketInputSchema: z.ZodType<Prisma.TicketReplyCreateManyTicketInput>;
+export declare const TicketReplyUpdateWithoutTicketInputSchema: z.ZodType<Prisma.TicketReplyUpdateWithoutTicketInput>;
+export declare const TicketReplyUncheckedUpdateWithoutTicketInputSchema: z.ZodType<Prisma.TicketReplyUncheckedUpdateWithoutTicketInput>;
+export declare const TicketReplyUncheckedUpdateManyWithoutTicketInputSchema: z.ZodType<Prisma.TicketReplyUncheckedUpdateManyWithoutTicketInput>;
+export declare const InNodeGroupDNSCreateManyDns_providerInputSchema: z.ZodType<Prisma.InNodeGroupDNSCreateManyDns_providerInput>;
+export declare const InNodeGroupDNSUpdateWithoutDns_providerInputSchema: z.ZodType<Prisma.InNodeGroupDNSUpdateWithoutDns_providerInput>;
+export declare const InNodeGroupDNSUncheckedUpdateWithoutDns_providerInputSchema: z.ZodType<Prisma.InNodeGroupDNSUncheckedUpdateWithoutDns_providerInput>;
+export declare const InNodeGroupDNSUncheckedUpdateManyWithoutDns_providerInputSchema: z.ZodType<Prisma.InNodeGroupDNSUncheckedUpdateManyWithoutDns_providerInput>;
+export declare const NodeGroupFindFirstArgsSchema: z.ZodType<Prisma.NodeGroupFindFirstArgs>;
+export declare const NodeGroupFindFirstOrThrowArgsSchema: z.ZodType<Prisma.NodeGroupFindFirstOrThrowArgs>;
+export declare const NodeGroupFindManyArgsSchema: z.ZodType<Prisma.NodeGroupFindManyArgs>;
+export declare const NodeGroupAggregateArgsSchema: z.ZodType<Prisma.NodeGroupAggregateArgs>;
+export declare const NodeGroupGroupByArgsSchema: z.ZodType<Prisma.NodeGroupGroupByArgs>;
+export declare const NodeGroupFindUniqueArgsSchema: z.ZodType<Prisma.NodeGroupFindUniqueArgs>;
+export declare const NodeGroupFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.NodeGroupFindUniqueOrThrowArgs>;
+export declare const NodeFindFirstArgsSchema: z.ZodType<Prisma.NodeFindFirstArgs>;
+export declare const NodeFindFirstOrThrowArgsSchema: z.ZodType<Prisma.NodeFindFirstOrThrowArgs>;
+export declare const NodeFindManyArgsSchema: z.ZodType<Prisma.NodeFindManyArgs>;
+export declare const NodeAggregateArgsSchema: z.ZodType<Prisma.NodeAggregateArgs>;
+export declare const NodeGroupByArgsSchema: z.ZodType<Prisma.NodeGroupByArgs>;
+export declare const NodeFindUniqueArgsSchema: z.ZodType<Prisma.NodeFindUniqueArgs>;
+export declare const NodeFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.NodeFindUniqueOrThrowArgs>;
+export declare const TunnelFindFirstArgsSchema: z.ZodType<Prisma.TunnelFindFirstArgs>;
+export declare const TunnelFindFirstOrThrowArgsSchema: z.ZodType<Prisma.TunnelFindFirstOrThrowArgs>;
+export declare const TunnelFindManyArgsSchema: z.ZodType<Prisma.TunnelFindManyArgs>;
+export declare const TunnelAggregateArgsSchema: z.ZodType<Prisma.TunnelAggregateArgs>;
+export declare const TunnelGroupByArgsSchema: z.ZodType<Prisma.TunnelGroupByArgs>;
+export declare const TunnelFindUniqueArgsSchema: z.ZodType<Prisma.TunnelFindUniqueArgs>;
+export declare const TunnelFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.TunnelFindUniqueOrThrowArgs>;
+export declare const TunnelChainFindFirstArgsSchema: z.ZodType<Prisma.TunnelChainFindFirstArgs>;
+export declare const TunnelChainFindFirstOrThrowArgsSchema: z.ZodType<Prisma.TunnelChainFindFirstOrThrowArgs>;
+export declare const TunnelChainFindManyArgsSchema: z.ZodType<Prisma.TunnelChainFindManyArgs>;
+export declare const TunnelChainAggregateArgsSchema: z.ZodType<Prisma.TunnelChainAggregateArgs>;
+export declare const TunnelChainGroupByArgsSchema: z.ZodType<Prisma.TunnelChainGroupByArgs>;
+export declare const TunnelChainFindUniqueArgsSchema: z.ZodType<Prisma.TunnelChainFindUniqueArgs>;
+export declare const TunnelChainFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.TunnelChainFindUniqueOrThrowArgs>;
+export declare const UserFindFirstArgsSchema: z.ZodType<Prisma.UserFindFirstArgs>;
+export declare const UserFindFirstOrThrowArgsSchema: z.ZodType<Prisma.UserFindFirstOrThrowArgs>;
+export declare const UserFindManyArgsSchema: z.ZodType<Prisma.UserFindManyArgs>;
+export declare const UserAggregateArgsSchema: z.ZodType<Prisma.UserAggregateArgs>;
+export declare const UserGroupByArgsSchema: z.ZodType<Prisma.UserGroupByArgs>;
+export declare const UserFindUniqueArgsSchema: z.ZodType<Prisma.UserFindUniqueArgs>;
+export declare const UserFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.UserFindUniqueOrThrowArgs>;
+export declare const UserPlanFindFirstArgsSchema: z.ZodType<Prisma.UserPlanFindFirstArgs>;
+export declare const UserPlanFindFirstOrThrowArgsSchema: z.ZodType<Prisma.UserPlanFindFirstOrThrowArgs>;
+export declare const UserPlanFindManyArgsSchema: z.ZodType<Prisma.UserPlanFindManyArgs>;
+export declare const UserPlanAggregateArgsSchema: z.ZodType<Prisma.UserPlanAggregateArgs>;
+export declare const UserPlanGroupByArgsSchema: z.ZodType<Prisma.UserPlanGroupByArgs>;
+export declare const UserPlanFindUniqueArgsSchema: z.ZodType<Prisma.UserPlanFindUniqueArgs>;
+export declare const UserPlanFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.UserPlanFindUniqueOrThrowArgs>;
+export declare const PlanFindFirstArgsSchema: z.ZodType<Prisma.PlanFindFirstArgs>;
+export declare const PlanFindFirstOrThrowArgsSchema: z.ZodType<Prisma.PlanFindFirstOrThrowArgs>;
+export declare const PlanFindManyArgsSchema: z.ZodType<Prisma.PlanFindManyArgs>;
+export declare const PlanAggregateArgsSchema: z.ZodType<Prisma.PlanAggregateArgs>;
+export declare const PlanGroupByArgsSchema: z.ZodType<Prisma.PlanGroupByArgs>;
+export declare const PlanFindUniqueArgsSchema: z.ZodType<Prisma.PlanFindUniqueArgs>;
+export declare const PlanFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.PlanFindUniqueOrThrowArgs>;
+export declare const PlanNodeGroupFindFirstArgsSchema: z.ZodType<Prisma.PlanNodeGroupFindFirstArgs>;
+export declare const PlanNodeGroupFindFirstOrThrowArgsSchema: z.ZodType<Prisma.PlanNodeGroupFindFirstOrThrowArgs>;
+export declare const PlanNodeGroupFindManyArgsSchema: z.ZodType<Prisma.PlanNodeGroupFindManyArgs>;
+export declare const PlanNodeGroupAggregateArgsSchema: z.ZodType<Prisma.PlanNodeGroupAggregateArgs>;
+export declare const PlanNodeGroupGroupByArgsSchema: z.ZodType<Prisma.PlanNodeGroupGroupByArgs>;
+export declare const PlanNodeGroupFindUniqueArgsSchema: z.ZodType<Prisma.PlanNodeGroupFindUniqueArgs>;
+export declare const PlanNodeGroupFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.PlanNodeGroupFindUniqueOrThrowArgs>;
+export declare const PlanOrderFindFirstArgsSchema: z.ZodType<Prisma.PlanOrderFindFirstArgs>;
+export declare const PlanOrderFindFirstOrThrowArgsSchema: z.ZodType<Prisma.PlanOrderFindFirstOrThrowArgs>;
+export declare const PlanOrderFindManyArgsSchema: z.ZodType<Prisma.PlanOrderFindManyArgs>;
+export declare const PlanOrderAggregateArgsSchema: z.ZodType<Prisma.PlanOrderAggregateArgs>;
+export declare const PlanOrderGroupByArgsSchema: z.ZodType<Prisma.PlanOrderGroupByArgs>;
+export declare const PlanOrderFindUniqueArgsSchema: z.ZodType<Prisma.PlanOrderFindUniqueArgs>;
+export declare const PlanOrderFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.PlanOrderFindUniqueOrThrowArgs>;
+export declare const TopupOrderFindFirstArgsSchema: z.ZodType<Prisma.TopupOrderFindFirstArgs>;
+export declare const TopupOrderFindFirstOrThrowArgsSchema: z.ZodType<Prisma.TopupOrderFindFirstOrThrowArgs>;
+export declare const TopupOrderFindManyArgsSchema: z.ZodType<Prisma.TopupOrderFindManyArgs>;
+export declare const TopupOrderAggregateArgsSchema: z.ZodType<Prisma.TopupOrderAggregateArgs>;
+export declare const TopupOrderGroupByArgsSchema: z.ZodType<Prisma.TopupOrderGroupByArgs>;
+export declare const TopupOrderFindUniqueArgsSchema: z.ZodType<Prisma.TopupOrderFindUniqueArgs>;
+export declare const TopupOrderFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.TopupOrderFindUniqueOrThrowArgs>;
+export declare const TopupActivityFindFirstArgsSchema: z.ZodType<Prisma.TopupActivityFindFirstArgs>;
+export declare const TopupActivityFindFirstOrThrowArgsSchema: z.ZodType<Prisma.TopupActivityFindFirstOrThrowArgs>;
+export declare const TopupActivityFindManyArgsSchema: z.ZodType<Prisma.TopupActivityFindManyArgs>;
+export declare const TopupActivityAggregateArgsSchema: z.ZodType<Prisma.TopupActivityAggregateArgs>;
+export declare const TopupActivityGroupByArgsSchema: z.ZodType<Prisma.TopupActivityGroupByArgs>;
+export declare const TopupActivityFindUniqueArgsSchema: z.ZodType<Prisma.TopupActivityFindUniqueArgs>;
+export declare const TopupActivityFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.TopupActivityFindUniqueOrThrowArgs>;
+export declare const TunnelTrafficFindFirstArgsSchema: z.ZodType<Prisma.TunnelTrafficFindFirstArgs>;
+export declare const TunnelTrafficFindFirstOrThrowArgsSchema: z.ZodType<Prisma.TunnelTrafficFindFirstOrThrowArgs>;
+export declare const TunnelTrafficFindManyArgsSchema: z.ZodType<Prisma.TunnelTrafficFindManyArgs>;
+export declare const TunnelTrafficAggregateArgsSchema: z.ZodType<Prisma.TunnelTrafficAggregateArgs>;
+export declare const TunnelTrafficGroupByArgsSchema: z.ZodType<Prisma.TunnelTrafficGroupByArgs>;
+export declare const TunnelTrafficFindUniqueArgsSchema: z.ZodType<Prisma.TunnelTrafficFindUniqueArgs>;
+export declare const TunnelTrafficFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.TunnelTrafficFindUniqueOrThrowArgs>;
+export declare const SystemConfigFindFirstArgsSchema: z.ZodType<Prisma.SystemConfigFindFirstArgs>;
+export declare const SystemConfigFindFirstOrThrowArgsSchema: z.ZodType<Prisma.SystemConfigFindFirstOrThrowArgs>;
+export declare const SystemConfigFindManyArgsSchema: z.ZodType<Prisma.SystemConfigFindManyArgs>;
+export declare const SystemConfigAggregateArgsSchema: z.ZodType<Prisma.SystemConfigAggregateArgs>;
+export declare const SystemConfigGroupByArgsSchema: z.ZodType<Prisma.SystemConfigGroupByArgs>;
+export declare const SystemConfigFindUniqueArgsSchema: z.ZodType<Prisma.SystemConfigFindUniqueArgs>;
+export declare const SystemConfigFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.SystemConfigFindUniqueOrThrowArgs>;
+export declare const PaymentFindFirstArgsSchema: z.ZodType<Prisma.PaymentFindFirstArgs>;
+export declare const PaymentFindFirstOrThrowArgsSchema: z.ZodType<Prisma.PaymentFindFirstOrThrowArgs>;
+export declare const PaymentFindManyArgsSchema: z.ZodType<Prisma.PaymentFindManyArgs>;
+export declare const PaymentAggregateArgsSchema: z.ZodType<Prisma.PaymentAggregateArgs>;
+export declare const PaymentGroupByArgsSchema: z.ZodType<Prisma.PaymentGroupByArgs>;
+export declare const PaymentFindUniqueArgsSchema: z.ZodType<Prisma.PaymentFindUniqueArgs>;
+export declare const PaymentFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.PaymentFindUniqueOrThrowArgs>;
+export declare const PlanCouponFindFirstArgsSchema: z.ZodType<Prisma.PlanCouponFindFirstArgs>;
+export declare const PlanCouponFindFirstOrThrowArgsSchema: z.ZodType<Prisma.PlanCouponFindFirstOrThrowArgs>;
+export declare const PlanCouponFindManyArgsSchema: z.ZodType<Prisma.PlanCouponFindManyArgs>;
+export declare const PlanCouponAggregateArgsSchema: z.ZodType<Prisma.PlanCouponAggregateArgs>;
+export declare const PlanCouponGroupByArgsSchema: z.ZodType<Prisma.PlanCouponGroupByArgs>;
+export declare const PlanCouponFindUniqueArgsSchema: z.ZodType<Prisma.PlanCouponFindUniqueArgs>;
+export declare const PlanCouponFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.PlanCouponFindUniqueOrThrowArgs>;
+export declare const BalanceLogFindFirstArgsSchema: z.ZodType<Prisma.BalanceLogFindFirstArgs>;
+export declare const BalanceLogFindFirstOrThrowArgsSchema: z.ZodType<Prisma.BalanceLogFindFirstOrThrowArgs>;
+export declare const BalanceLogFindManyArgsSchema: z.ZodType<Prisma.BalanceLogFindManyArgs>;
+export declare const BalanceLogAggregateArgsSchema: z.ZodType<Prisma.BalanceLogAggregateArgs>;
+export declare const BalanceLogGroupByArgsSchema: z.ZodType<Prisma.BalanceLogGroupByArgs>;
+export declare const BalanceLogFindUniqueArgsSchema: z.ZodType<Prisma.BalanceLogFindUniqueArgs>;
+export declare const BalanceLogFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.BalanceLogFindUniqueOrThrowArgs>;
+export declare const TicketFindFirstArgsSchema: z.ZodType<Prisma.TicketFindFirstArgs>;
+export declare const TicketFindFirstOrThrowArgsSchema: z.ZodType<Prisma.TicketFindFirstOrThrowArgs>;
+export declare const TicketFindManyArgsSchema: z.ZodType<Prisma.TicketFindManyArgs>;
+export declare const TicketAggregateArgsSchema: z.ZodType<Prisma.TicketAggregateArgs>;
+export declare const TicketGroupByArgsSchema: z.ZodType<Prisma.TicketGroupByArgs>;
+export declare const TicketFindUniqueArgsSchema: z.ZodType<Prisma.TicketFindUniqueArgs>;
+export declare const TicketFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.TicketFindUniqueOrThrowArgs>;
+export declare const TicketReplyFindFirstArgsSchema: z.ZodType<Prisma.TicketReplyFindFirstArgs>;
+export declare const TicketReplyFindFirstOrThrowArgsSchema: z.ZodType<Prisma.TicketReplyFindFirstOrThrowArgs>;
+export declare const TicketReplyFindManyArgsSchema: z.ZodType<Prisma.TicketReplyFindManyArgs>;
+export declare const TicketReplyAggregateArgsSchema: z.ZodType<Prisma.TicketReplyAggregateArgs>;
+export declare const TicketReplyGroupByArgsSchema: z.ZodType<Prisma.TicketReplyGroupByArgs>;
+export declare const TicketReplyFindUniqueArgsSchema: z.ZodType<Prisma.TicketReplyFindUniqueArgs>;
+export declare const TicketReplyFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.TicketReplyFindUniqueOrThrowArgs>;
+export declare const InNodeGroupDNSFindFirstArgsSchema: z.ZodType<Prisma.InNodeGroupDNSFindFirstArgs>;
+export declare const InNodeGroupDNSFindFirstOrThrowArgsSchema: z.ZodType<Prisma.InNodeGroupDNSFindFirstOrThrowArgs>;
+export declare const InNodeGroupDNSFindManyArgsSchema: z.ZodType<Prisma.InNodeGroupDNSFindManyArgs>;
+export declare const InNodeGroupDNSAggregateArgsSchema: z.ZodType<Prisma.InNodeGroupDNSAggregateArgs>;
+export declare const InNodeGroupDNSGroupByArgsSchema: z.ZodType<Prisma.InNodeGroupDNSGroupByArgs>;
+export declare const InNodeGroupDNSFindUniqueArgsSchema: z.ZodType<Prisma.InNodeGroupDNSFindUniqueArgs>;
+export declare const InNodeGroupDNSFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.InNodeGroupDNSFindUniqueOrThrowArgs>;
+export declare const DNSProviderFindFirstArgsSchema: z.ZodType<Prisma.DNSProviderFindFirstArgs>;
+export declare const DNSProviderFindFirstOrThrowArgsSchema: z.ZodType<Prisma.DNSProviderFindFirstOrThrowArgs>;
+export declare const DNSProviderFindManyArgsSchema: z.ZodType<Prisma.DNSProviderFindManyArgs>;
+export declare const DNSProviderAggregateArgsSchema: z.ZodType<Prisma.DNSProviderAggregateArgs>;
+export declare const DNSProviderGroupByArgsSchema: z.ZodType<Prisma.DNSProviderGroupByArgs>;
+export declare const DNSProviderFindUniqueArgsSchema: z.ZodType<Prisma.DNSProviderFindUniqueArgs>;
+export declare const DNSProviderFindUniqueOrThrowArgsSchema: z.ZodType<Prisma.DNSProviderFindUniqueOrThrowArgs>;
+export declare const NodeGroupCreateArgsSchema: z.ZodType<Prisma.NodeGroupCreateArgs>;
+export declare const NodeGroupUpsertArgsSchema: z.ZodType<Prisma.NodeGroupUpsertArgs>;
+export declare const NodeGroupCreateManyArgsSchema: z.ZodType<Prisma.NodeGroupCreateManyArgs>;
+export declare const NodeGroupDeleteArgsSchema: z.ZodType<Prisma.NodeGroupDeleteArgs>;
+export declare const NodeGroupUpdateArgsSchema: z.ZodType<Prisma.NodeGroupUpdateArgs>;
+export declare const NodeGroupUpdateManyArgsSchema: z.ZodType<Prisma.NodeGroupUpdateManyArgs>;
+export declare const NodeGroupDeleteManyArgsSchema: z.ZodType<Prisma.NodeGroupDeleteManyArgs>;
+export declare const NodeCreateArgsSchema: z.ZodType<Prisma.NodeCreateArgs>;
+export declare const NodeUpsertArgsSchema: z.ZodType<Prisma.NodeUpsertArgs>;
+export declare const NodeCreateManyArgsSchema: z.ZodType<Prisma.NodeCreateManyArgs>;
+export declare const NodeDeleteArgsSchema: z.ZodType<Prisma.NodeDeleteArgs>;
+export declare const NodeUpdateArgsSchema: z.ZodType<Prisma.NodeUpdateArgs>;
+export declare const NodeUpdateManyArgsSchema: z.ZodType<Prisma.NodeUpdateManyArgs>;
+export declare const NodeDeleteManyArgsSchema: z.ZodType<Prisma.NodeDeleteManyArgs>;
+export declare const TunnelCreateArgsSchema: z.ZodType<Prisma.TunnelCreateArgs>;
+export declare const TunnelUpsertArgsSchema: z.ZodType<Prisma.TunnelUpsertArgs>;
+export declare const TunnelCreateManyArgsSchema: z.ZodType<Prisma.TunnelCreateManyArgs>;
+export declare const TunnelDeleteArgsSchema: z.ZodType<Prisma.TunnelDeleteArgs>;
+export declare const TunnelUpdateArgsSchema: z.ZodType<Prisma.TunnelUpdateArgs>;
+export declare const TunnelUpdateManyArgsSchema: z.ZodType<Prisma.TunnelUpdateManyArgs>;
+export declare const TunnelDeleteManyArgsSchema: z.ZodType<Prisma.TunnelDeleteManyArgs>;
+export declare const TunnelChainCreateArgsSchema: z.ZodType<Prisma.TunnelChainCreateArgs>;
+export declare const TunnelChainUpsertArgsSchema: z.ZodType<Prisma.TunnelChainUpsertArgs>;
+export declare const TunnelChainCreateManyArgsSchema: z.ZodType<Prisma.TunnelChainCreateManyArgs>;
+export declare const TunnelChainDeleteArgsSchema: z.ZodType<Prisma.TunnelChainDeleteArgs>;
+export declare const TunnelChainUpdateArgsSchema: z.ZodType<Prisma.TunnelChainUpdateArgs>;
+export declare const TunnelChainUpdateManyArgsSchema: z.ZodType<Prisma.TunnelChainUpdateManyArgs>;
+export declare const TunnelChainDeleteManyArgsSchema: z.ZodType<Prisma.TunnelChainDeleteManyArgs>;
+export declare const UserCreateArgsSchema: z.ZodType<Prisma.UserCreateArgs>;
+export declare const UserUpsertArgsSchema: z.ZodType<Prisma.UserUpsertArgs>;
+export declare const UserCreateManyArgsSchema: z.ZodType<Prisma.UserCreateManyArgs>;
+export declare const UserDeleteArgsSchema: z.ZodType<Prisma.UserDeleteArgs>;
+export declare const UserUpdateArgsSchema: z.ZodType<Prisma.UserUpdateArgs>;
+export declare const UserUpdateManyArgsSchema: z.ZodType<Prisma.UserUpdateManyArgs>;
+export declare const UserDeleteManyArgsSchema: z.ZodType<Prisma.UserDeleteManyArgs>;
+export declare const UserPlanCreateArgsSchema: z.ZodType<Prisma.UserPlanCreateArgs>;
+export declare const UserPlanUpsertArgsSchema: z.ZodType<Prisma.UserPlanUpsertArgs>;
+export declare const UserPlanCreateManyArgsSchema: z.ZodType<Prisma.UserPlanCreateManyArgs>;
+export declare const UserPlanDeleteArgsSchema: z.ZodType<Prisma.UserPlanDeleteArgs>;
+export declare const UserPlanUpdateArgsSchema: z.ZodType<Prisma.UserPlanUpdateArgs>;
+export declare const UserPlanUpdateManyArgsSchema: z.ZodType<Prisma.UserPlanUpdateManyArgs>;
+export declare const UserPlanDeleteManyArgsSchema: z.ZodType<Prisma.UserPlanDeleteManyArgs>;
+export declare const PlanCreateArgsSchema: z.ZodType<Prisma.PlanCreateArgs>;
+export declare const PlanUpsertArgsSchema: z.ZodType<Prisma.PlanUpsertArgs>;
+export declare const PlanCreateManyArgsSchema: z.ZodType<Prisma.PlanCreateManyArgs>;
+export declare const PlanDeleteArgsSchema: z.ZodType<Prisma.PlanDeleteArgs>;
+export declare const PlanUpdateArgsSchema: z.ZodType<Prisma.PlanUpdateArgs>;
+export declare const PlanUpdateManyArgsSchema: z.ZodType<Prisma.PlanUpdateManyArgs>;
+export declare const PlanDeleteManyArgsSchema: z.ZodType<Prisma.PlanDeleteManyArgs>;
+export declare const PlanNodeGroupCreateArgsSchema: z.ZodType<Prisma.PlanNodeGroupCreateArgs>;
+export declare const PlanNodeGroupUpsertArgsSchema: z.ZodType<Prisma.PlanNodeGroupUpsertArgs>;
+export declare const PlanNodeGroupCreateManyArgsSchema: z.ZodType<Prisma.PlanNodeGroupCreateManyArgs>;
+export declare const PlanNodeGroupDeleteArgsSchema: z.ZodType<Prisma.PlanNodeGroupDeleteArgs>;
+export declare const PlanNodeGroupUpdateArgsSchema: z.ZodType<Prisma.PlanNodeGroupUpdateArgs>;
+export declare const PlanNodeGroupUpdateManyArgsSchema: z.ZodType<Prisma.PlanNodeGroupUpdateManyArgs>;
+export declare const PlanNodeGroupDeleteManyArgsSchema: z.ZodType<Prisma.PlanNodeGroupDeleteManyArgs>;
+export declare const PlanOrderCreateArgsSchema: z.ZodType<Prisma.PlanOrderCreateArgs>;
+export declare const PlanOrderUpsertArgsSchema: z.ZodType<Prisma.PlanOrderUpsertArgs>;
+export declare const PlanOrderCreateManyArgsSchema: z.ZodType<Prisma.PlanOrderCreateManyArgs>;
+export declare const PlanOrderDeleteArgsSchema: z.ZodType<Prisma.PlanOrderDeleteArgs>;
+export declare const PlanOrderUpdateArgsSchema: z.ZodType<Prisma.PlanOrderUpdateArgs>;
+export declare const PlanOrderUpdateManyArgsSchema: z.ZodType<Prisma.PlanOrderUpdateManyArgs>;
+export declare const PlanOrderDeleteManyArgsSchema: z.ZodType<Prisma.PlanOrderDeleteManyArgs>;
+export declare const TopupOrderCreateArgsSchema: z.ZodType<Prisma.TopupOrderCreateArgs>;
+export declare const TopupOrderUpsertArgsSchema: z.ZodType<Prisma.TopupOrderUpsertArgs>;
+export declare const TopupOrderCreateManyArgsSchema: z.ZodType<Prisma.TopupOrderCreateManyArgs>;
+export declare const TopupOrderDeleteArgsSchema: z.ZodType<Prisma.TopupOrderDeleteArgs>;
+export declare const TopupOrderUpdateArgsSchema: z.ZodType<Prisma.TopupOrderUpdateArgs>;
+export declare const TopupOrderUpdateManyArgsSchema: z.ZodType<Prisma.TopupOrderUpdateManyArgs>;
+export declare const TopupOrderDeleteManyArgsSchema: z.ZodType<Prisma.TopupOrderDeleteManyArgs>;
+export declare const TopupActivityCreateArgsSchema: z.ZodType<Prisma.TopupActivityCreateArgs>;
+export declare const TopupActivityUpsertArgsSchema: z.ZodType<Prisma.TopupActivityUpsertArgs>;
+export declare const TopupActivityCreateManyArgsSchema: z.ZodType<Prisma.TopupActivityCreateManyArgs>;
+export declare const TopupActivityDeleteArgsSchema: z.ZodType<Prisma.TopupActivityDeleteArgs>;
+export declare const TopupActivityUpdateArgsSchema: z.ZodType<Prisma.TopupActivityUpdateArgs>;
+export declare const TopupActivityUpdateManyArgsSchema: z.ZodType<Prisma.TopupActivityUpdateManyArgs>;
+export declare const TopupActivityDeleteManyArgsSchema: z.ZodType<Prisma.TopupActivityDeleteManyArgs>;
+export declare const TunnelTrafficCreateArgsSchema: z.ZodType<Prisma.TunnelTrafficCreateArgs>;
+export declare const TunnelTrafficUpsertArgsSchema: z.ZodType<Prisma.TunnelTrafficUpsertArgs>;
+export declare const TunnelTrafficCreateManyArgsSchema: z.ZodType<Prisma.TunnelTrafficCreateManyArgs>;
+export declare const TunnelTrafficDeleteArgsSchema: z.ZodType<Prisma.TunnelTrafficDeleteArgs>;
+export declare const TunnelTrafficUpdateArgsSchema: z.ZodType<Prisma.TunnelTrafficUpdateArgs>;
+export declare const TunnelTrafficUpdateManyArgsSchema: z.ZodType<Prisma.TunnelTrafficUpdateManyArgs>;
+export declare const TunnelTrafficDeleteManyArgsSchema: z.ZodType<Prisma.TunnelTrafficDeleteManyArgs>;
+export declare const SystemConfigCreateArgsSchema: z.ZodType<Prisma.SystemConfigCreateArgs>;
+export declare const SystemConfigUpsertArgsSchema: z.ZodType<Prisma.SystemConfigUpsertArgs>;
+export declare const SystemConfigCreateManyArgsSchema: z.ZodType<Prisma.SystemConfigCreateManyArgs>;
+export declare const SystemConfigDeleteArgsSchema: z.ZodType<Prisma.SystemConfigDeleteArgs>;
+export declare const SystemConfigUpdateArgsSchema: z.ZodType<Prisma.SystemConfigUpdateArgs>;
+export declare const SystemConfigUpdateManyArgsSchema: z.ZodType<Prisma.SystemConfigUpdateManyArgs>;
+export declare const SystemConfigDeleteManyArgsSchema: z.ZodType<Prisma.SystemConfigDeleteManyArgs>;
+export declare const PaymentCreateArgsSchema: z.ZodType<Prisma.PaymentCreateArgs>;
+export declare const PaymentUpsertArgsSchema: z.ZodType<Prisma.PaymentUpsertArgs>;
+export declare const PaymentCreateManyArgsSchema: z.ZodType<Prisma.PaymentCreateManyArgs>;
+export declare const PaymentDeleteArgsSchema: z.ZodType<Prisma.PaymentDeleteArgs>;
+export declare const PaymentUpdateArgsSchema: z.ZodType<Prisma.PaymentUpdateArgs>;
+export declare const PaymentUpdateManyArgsSchema: z.ZodType<Prisma.PaymentUpdateManyArgs>;
+export declare const PaymentDeleteManyArgsSchema: z.ZodType<Prisma.PaymentDeleteManyArgs>;
+export declare const PlanCouponCreateArgsSchema: z.ZodType<Prisma.PlanCouponCreateArgs>;
+export declare const PlanCouponUpsertArgsSchema: z.ZodType<Prisma.PlanCouponUpsertArgs>;
+export declare const PlanCouponCreateManyArgsSchema: z.ZodType<Prisma.PlanCouponCreateManyArgs>;
+export declare const PlanCouponDeleteArgsSchema: z.ZodType<Prisma.PlanCouponDeleteArgs>;
+export declare const PlanCouponUpdateArgsSchema: z.ZodType<Prisma.PlanCouponUpdateArgs>;
+export declare const PlanCouponUpdateManyArgsSchema: z.ZodType<Prisma.PlanCouponUpdateManyArgs>;
+export declare const PlanCouponDeleteManyArgsSchema: z.ZodType<Prisma.PlanCouponDeleteManyArgs>;
+export declare const BalanceLogCreateArgsSchema: z.ZodType<Prisma.BalanceLogCreateArgs>;
+export declare const BalanceLogUpsertArgsSchema: z.ZodType<Prisma.BalanceLogUpsertArgs>;
+export declare const BalanceLogCreateManyArgsSchema: z.ZodType<Prisma.BalanceLogCreateManyArgs>;
+export declare const BalanceLogDeleteArgsSchema: z.ZodType<Prisma.BalanceLogDeleteArgs>;
+export declare const BalanceLogUpdateArgsSchema: z.ZodType<Prisma.BalanceLogUpdateArgs>;
+export declare const BalanceLogUpdateManyArgsSchema: z.ZodType<Prisma.BalanceLogUpdateManyArgs>;
+export declare const BalanceLogDeleteManyArgsSchema: z.ZodType<Prisma.BalanceLogDeleteManyArgs>;
+export declare const TicketCreateArgsSchema: z.ZodType<Prisma.TicketCreateArgs>;
+export declare const TicketUpsertArgsSchema: z.ZodType<Prisma.TicketUpsertArgs>;
+export declare const TicketCreateManyArgsSchema: z.ZodType<Prisma.TicketCreateManyArgs>;
+export declare const TicketDeleteArgsSchema: z.ZodType<Prisma.TicketDeleteArgs>;
+export declare const TicketUpdateArgsSchema: z.ZodType<Prisma.TicketUpdateArgs>;
+export declare const TicketUpdateManyArgsSchema: z.ZodType<Prisma.TicketUpdateManyArgs>;
+export declare const TicketDeleteManyArgsSchema: z.ZodType<Prisma.TicketDeleteManyArgs>;
+export declare const TicketReplyCreateArgsSchema: z.ZodType<Prisma.TicketReplyCreateArgs>;
+export declare const TicketReplyUpsertArgsSchema: z.ZodType<Prisma.TicketReplyUpsertArgs>;
+export declare const TicketReplyCreateManyArgsSchema: z.ZodType<Prisma.TicketReplyCreateManyArgs>;
+export declare const TicketReplyDeleteArgsSchema: z.ZodType<Prisma.TicketReplyDeleteArgs>;
+export declare const TicketReplyUpdateArgsSchema: z.ZodType<Prisma.TicketReplyUpdateArgs>;
+export declare const TicketReplyUpdateManyArgsSchema: z.ZodType<Prisma.TicketReplyUpdateManyArgs>;
+export declare const TicketReplyDeleteManyArgsSchema: z.ZodType<Prisma.TicketReplyDeleteManyArgs>;
+export declare const InNodeGroupDNSCreateArgsSchema: z.ZodType<Prisma.InNodeGroupDNSCreateArgs>;
+export declare const InNodeGroupDNSUpsertArgsSchema: z.ZodType<Prisma.InNodeGroupDNSUpsertArgs>;
+export declare const InNodeGroupDNSCreateManyArgsSchema: z.ZodType<Prisma.InNodeGroupDNSCreateManyArgs>;
+export declare const InNodeGroupDNSDeleteArgsSchema: z.ZodType<Prisma.InNodeGroupDNSDeleteArgs>;
+export declare const InNodeGroupDNSUpdateArgsSchema: z.ZodType<Prisma.InNodeGroupDNSUpdateArgs>;
+export declare const InNodeGroupDNSUpdateManyArgsSchema: z.ZodType<Prisma.InNodeGroupDNSUpdateManyArgs>;
+export declare const InNodeGroupDNSDeleteManyArgsSchema: z.ZodType<Prisma.InNodeGroupDNSDeleteManyArgs>;
+export declare const DNSProviderCreateArgsSchema: z.ZodType<Prisma.DNSProviderCreateArgs>;
+export declare const DNSProviderUpsertArgsSchema: z.ZodType<Prisma.DNSProviderUpsertArgs>;
+export declare const DNSProviderCreateManyArgsSchema: z.ZodType<Prisma.DNSProviderCreateManyArgs>;
+export declare const DNSProviderDeleteArgsSchema: z.ZodType<Prisma.DNSProviderDeleteArgs>;
+export declare const DNSProviderUpdateArgsSchema: z.ZodType<Prisma.DNSProviderUpdateArgs>;
+export declare const DNSProviderUpdateManyArgsSchema: z.ZodType<Prisma.DNSProviderUpdateManyArgs>;
+export declare const DNSProviderDeleteManyArgsSchema: z.ZodType<Prisma.DNSProviderDeleteManyArgs>;