wapi-client 0.12.5-beta.4 → 0.12.5-beta.9

package/dist/db/consts.cjs

@@ -1,12 +1,10 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -34,14 +32,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/db/consts.ts
@@ -102,34 +92,34 @@ __export(consts_exports, {
 });
 module.exports = __toCommonJS(consts_exports);
 var import_ts_utils = require('../lib/ts-utils.cjs');
-var import_zod = __toESM(require("zod"), 1);
-var MetadataSchema = import_zod.default.record(
-  import_zod.default.string(),
-  import_zod.default.union([
-    import_zod.default.string(),
-    import_zod.default.boolean(),
-    import_zod.default.number(),
-    import_zod.default.null(),
-    import_zod.default.undefined(),
-    import_zod.default.lazy(() => MetadataSchema),
-    import_zod.default.union([
-      import_zod.default.string(),
-      import_zod.default.boolean(),
-      import_zod.default.number(),
-      import_zod.default.null(),
-      import_zod.default.undefined(),
-      import_zod.default.lazy(() => MetadataSchema)
+var import_zod = require('../lib/zod.cjs');
+var MetadataSchema = import_zod.z.record(
+  import_zod.z.string(),
+  import_zod.z.union([
+    import_zod.z.string(),
+    import_zod.z.boolean(),
+    import_zod.z.number(),
+    import_zod.z.null(),
+    import_zod.z.undefined(),
+    import_zod.z.lazy(() => MetadataSchema),
+    import_zod.z.union([
+      import_zod.z.string(),
+      import_zod.z.boolean(),
+      import_zod.z.number(),
+      import_zod.z.null(),
+      import_zod.z.undefined(),
+      import_zod.z.lazy(() => MetadataSchema)
     ]).array()
   ])
 ).nullable().describe("Custom key/value object");
-var DatetimeSchema = import_zod.default.union([
-  import_zod.default.string().datetime({ offset: true, local: true }),
-  import_zod.default.string({
+var DatetimeSchema = import_zod.z.union([
+  import_zod.z.string().datetime({ offset: true, local: true }),
+  import_zod.z.string({
     invalid_type_error: "must be a valid date-time string"
   }).regex(/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/),
-  import_zod.default.string().date()
+  import_zod.z.string().date()
 ]);
-var DbTimezone = import_zod.default.enum([
+var DbTimezone = import_zod.z.enum([
   "Africa/Abidjan",
   "Africa/Accra",
   "Africa/Addis_Ababa",
@@ -728,13 +718,13 @@ var DbTimezone = import_zod.default.enum([
   "WET",
   "Zulu"
 ]).describe("Timezones allowed");
-var flagsSchema = import_zod.default.object({
-  allow_timestamps: import_zod.default.boolean().describe(
+var flagsSchema = import_zod.z.object({
+  allow_timestamps: import_zod.z.boolean().describe(
     "Allow setting timestamps in transfer insert/update statements"
   ),
-  production: import_zod.default.boolean().describe("Is running in production mode?")
+  production: import_zod.z.boolean().describe("Is running in production mode?")
 }).partial().describe("System wide flags");
-var DbModelNameSchema = import_zod.default.enum([
+var DbModelNameSchema = import_zod.z.enum([
   "Token",
   "TransferGroup",
   "TransferLog",
@@ -744,50 +734,50 @@ var DbModelNameSchema = import_zod.default.enum([
   "WapiSetting"
 ]);
 var DbModelNameEnum = (0, import_ts_utils.createEnumFromTuple)(DbModelNameSchema.options);
-var DbFilterOperatorEqualsSchema = import_zod.default.enum(["="]);
-var DbFilterOperatorBasicSchema = import_zod.default.enum([">=", "<=", "<", ">"]);
-var DbFilterOperatorStringSchema = import_zod.default.enum(["like", "ilike"]);
-var DbFilterOperatorForNumbersSchema = import_zod.default.enum([
+var DbFilterOperatorEqualsSchema = import_zod.z.enum(["="]);
+var DbFilterOperatorBasicSchema = import_zod.z.enum([">=", "<=", "<", ">"]);
+var DbFilterOperatorStringSchema = import_zod.z.enum(["like", "ilike"]);
+var DbFilterOperatorForNumbersSchema = import_zod.z.enum([
   ...DbFilterOperatorEqualsSchema.options,
   ...DbFilterOperatorBasicSchema.options
 ]).default("=");
-var DbFilterOperatorForStringsSchema = import_zod.default.enum([
+var DbFilterOperatorForStringsSchema = import_zod.z.enum([
   ...DbFilterOperatorEqualsSchema.options,
   ...DbFilterOperatorBasicSchema.options,
   ...DbFilterOperatorStringSchema.options
 ]).default("=");
-var DbFilterOperatorAllSchema = import_zod.default.enum([
+var DbFilterOperatorAllSchema = import_zod.z.enum([
   ...DbFilterOperatorEqualsSchema.options,
   ...DbFilterOperatorBasicSchema.options,
   ...DbFilterOperatorStringSchema.options
   // ...DbFilterOperatorInSchema.options,
   // ...DbFilterOperatorNullSchema.options,
 ]);
-var DbFilterAllowedValueSchema = import_zod.default.union([
-  import_zod.default.string(),
-  import_zod.default.boolean(),
-  import_zod.default.number()
+var DbFilterAllowedValueSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.boolean(),
+  import_zod.z.number()
 ]);
-var DbFilterForeignSchema = import_zod.default.object({
-  foreign: import_zod.default.union([import_zod.default.string(), import_zod.default.number()])
+var DbFilterForeignSchema = import_zod.z.object({
+  foreign: import_zod.z.union([import_zod.z.string(), import_zod.z.number()])
 });
-var DbFilterIdentifierSchema = import_zod.default.object({
-  identifier: import_zod.default.union([import_zod.default.string(), import_zod.default.number()])
+var DbFilterIdentifierSchema = import_zod.z.object({
+  identifier: import_zod.z.union([import_zod.z.string(), import_zod.z.number()])
 });
-var DbFilterAllowedKeySchema = import_zod.default.string().regex(
+var DbFilterAllowedKeySchema = import_zod.z.string().regex(
   /^(?!.*\.\.)[a-zA-Z_][a-zA-Z0-9_.-]*[a-zA-Z0-9_-]$/,
   "Key is limited to [a-zA-Z0-9_-] and cant start with a number"
 );
-var DbFilterStringNumberArraySchema = import_zod.default.union([
-  import_zod.default.string().array().min(1),
-  import_zod.default.number().array().min(1)
+var DbFilterStringNumberArraySchema = import_zod.z.union([
+  import_zod.z.string().array().min(1),
+  import_zod.z.number().array().min(1)
 ]);
-var DbFilterMetadataSchema = import_zod.default.record(DbFilterAllowedKeySchema, DbFilterAllowedValueSchema).describe("Metadata filter for custom properties");
-var DbFilterFunctionBasicSchema = import_zod.default.enum(["where", "orWhere"]);
+var DbFilterMetadataSchema = import_zod.z.record(DbFilterAllowedKeySchema, DbFilterAllowedValueSchema).describe("Metadata filter for custom properties");
+var DbFilterFunctionBasicSchema = import_zod.z.enum(["where", "orWhere"]);
 var DbFilterFunctionBasicEnum = (0, import_ts_utils.createEnumFromTuple)(
   DbFilterFunctionBasicSchema.options
 );
-var DbFilterFunctionNullSchema = import_zod.default.enum([
+var DbFilterFunctionNullSchema = import_zod.z.enum([
   "whereNull",
   "orWhereNull",
   "whereNotNull",
@@ -796,18 +786,18 @@ var DbFilterFunctionNullSchema = import_zod.default.enum([
 var DbFilterFunctionNullEnum = (0, import_ts_utils.createEnumFromTuple)(
   DbFilterFunctionNullSchema.options
 );
-var DbFilterFunctionInSchema = import_zod.default.enum(["whereIn", "orWhereIn"]);
+var DbFilterFunctionInSchema = import_zod.z.enum(["whereIn", "orWhereIn"]);
 var DbFilterFunctionInEnum = (0, import_ts_utils.createEnumFromTuple)(
   DbFilterFunctionInSchema.options
 );
-var DbFilterFunctionMetadataBasicSchema = import_zod.default.enum([
+var DbFilterFunctionMetadataBasicSchema = import_zod.z.enum([
   "whereMetadata",
   "orWhereMetadata"
 ]);
 var DbFilterFunctionMetadataBasicEnum = (0, import_ts_utils.createEnumFromTuple)(
   DbFilterFunctionMetadataBasicSchema.options
 );
-var DbFilterFunctionMetadataNullSchema = import_zod.default.enum([
+var DbFilterFunctionMetadataNullSchema = import_zod.z.enum([
   "whereMetadataNull",
   "orWhereMetadataNull",
   "whereMetadataNotNull",
@@ -816,41 +806,41 @@ var DbFilterFunctionMetadataNullSchema = import_zod.default.enum([
 var DbFilterFunctionMetadataNullEnum = (0, import_ts_utils.createEnumFromTuple)(
   DbFilterFunctionMetadataNullSchema.options
 );
-var DbFilterFunctionMetadataInSchema = import_zod.default.enum([
+var DbFilterFunctionMetadataInSchema = import_zod.z.enum([
   "whereMetadataIn",
   "orWhereMetadataIn"
 ]);
 var DbFilterFunctionMetadataInEnum = (0, import_ts_utils.createEnumFromTuple)(
   DbFilterFunctionMetadataInSchema.options
 );
-var DbFilterOperatorExtendedSchema = import_zod.default.enum(["=", ">=", "<=", "<", ">", "ilike", "like"]).default("=");
-var DbFilterFunctionWherePrimitiveSchema = import_zod.default.object({
+var DbFilterOperatorExtendedSchema = import_zod.z.enum(["=", ">=", "<=", "<", ">", "ilike", "like"]).default("=");
+var DbFilterFunctionWherePrimitiveSchema = import_zod.z.object({
   function: DbFilterFunctionBasicSchema,
   field: DbFilterAllowedKeySchema,
   operator: DbFilterOperatorExtendedSchema.optional(),
   value: DbFilterAllowedValueSchema
 }).describe("Filtering for where and orWhere");
-var DbFilterFunctionWhereForeignAllowedSchema = import_zod.default.union([
+var DbFilterFunctionWhereForeignAllowedSchema = import_zod.z.union([
   DbFilterAllowedValueSchema,
   DbFilterForeignSchema
 ]);
-var DbFilterFunctionWherePrimitiveForeignSchema = import_zod.default.object({
+var DbFilterFunctionWherePrimitiveForeignSchema = import_zod.z.object({
   function: DbFilterFunctionBasicSchema,
   field: DbFilterAllowedKeySchema,
   operator: DbFilterOperatorExtendedSchema.optional(),
   value: DbFilterFunctionWhereForeignAllowedSchema
 }).describe("Filtering for where and orWhere");
-var DbFilterFunctionWhereIdentifierAllowedSchema = import_zod.default.union([
+var DbFilterFunctionWhereIdentifierAllowedSchema = import_zod.z.union([
   DbFilterAllowedValueSchema,
   DbFilterIdentifierSchema
 ]);
-var DbFilterFunctionWherePrimitiveIdentifierSchema = import_zod.default.object({
+var DbFilterFunctionWherePrimitiveIdentifierSchema = import_zod.z.object({
   function: DbFilterFunctionBasicSchema,
   field: DbFilterAllowedKeySchema,
   operator: DbFilterOperatorExtendedSchema.optional(),
   value: DbFilterFunctionWhereIdentifierAllowedSchema
 }).describe("Filtering for where and orWhere");
-var DbFilterFunctionWhereMetadataPrimitiveSchema = import_zod.default.object({
+var DbFilterFunctionWhereMetadataPrimitiveSchema = import_zod.z.object({
   function: DbFilterFunctionMetadataBasicSchema,
   field: DbFilterAllowedKeySchema,
   operator: DbFilterOperatorExtendedSchema.optional(),
@@ -860,44 +850,44 @@ var DbFilterFunctionWhereMetadataPrimitiveSchema = import_zod.default.object({
   field: true,
   value: true
 }).describe("Filtering for where and orWhere");
-var DbFilterMetadataObjectSchema = import_zod.default.object({
+var DbFilterMetadataObjectSchema = import_zod.z.object({
   metadata: DbFilterMetadataSchema.optional()
 }).catchall(DbFilterAllowedValueSchema);
-var DbFilterAllowedValueOrMetadataSchema = import_zod.default.union([
+var DbFilterAllowedValueOrMetadataSchema = import_zod.z.union([
   DbFilterAllowedValueSchema,
   DbFilterMetadataSchema
 ]);
-var DbFilterFunctionWhereObjectSchema = import_zod.default.object({
+var DbFilterFunctionWhereObjectSchema = import_zod.z.object({
   function: DbFilterFunctionBasicSchema,
   value: DbFilterMetadataObjectSchema
 });
-var DbFilterFunctionWherePrimitiveObjectSchema = import_zod.default.union([
+var DbFilterFunctionWherePrimitiveObjectSchema = import_zod.z.union([
   DbFilterFunctionWherePrimitiveSchema,
   DbFilterFunctionWhereObjectSchema
 ]);
-var DbFilterFunctionWhereInSchema = import_zod.default.object({
+var DbFilterFunctionWhereInSchema = import_zod.z.object({
   function: DbFilterFunctionInSchema,
   field: DbFilterAllowedKeySchema,
   value: DbFilterStringNumberArraySchema
 });
-var DbFilterFunctionWhereMetadataInSchema = import_zod.default.object({
+var DbFilterFunctionWhereMetadataInSchema = import_zod.z.object({
   function: DbFilterFunctionMetadataInSchema,
   field: DbFilterAllowedKeySchema,
   value: DbFilterStringNumberArraySchema
 });
-var DbFilterFunctionWhereNullSchema = import_zod.default.object({
+var DbFilterFunctionWhereNullSchema = import_zod.z.object({
   function: DbFilterFunctionNullSchema,
   field: DbFilterAllowedKeySchema
 }).describe(
   "Filtering for whereNull and orWhereNull, whereNotNull and orWhereNotNull"
 );
-var DbFilterFunctionWhereMetadataNullSchema = import_zod.default.object({
+var DbFilterFunctionWhereMetadataNullSchema = import_zod.z.object({
   function: DbFilterFunctionMetadataNullSchema,
   field: DbFilterAllowedKeySchema
 }).describe(
   "Filtering for whereNull and orWhereNull, whereNotNull and orWhereNotNull for metadata"
 );
-var DbFilterMetadataFilteringSchema = import_zod.default.discriminatedUnion(
+var DbFilterMetadataFilteringSchema = import_zod.z.discriminatedUnion(
   "function",
   [
     DbFilterFunctionWhereMetadataPrimitiveSchema,
@@ -905,21 +895,21 @@ var DbFilterMetadataFilteringSchema = import_zod.default.discriminatedUnion(
     DbFilterFunctionWhereMetadataNullSchema
   ]
 );
-var DbFilterSchema = import_zod.default.union([
+var DbFilterSchema = import_zod.z.union([
   DbFilterFunctionWherePrimitiveObjectSchema,
   DbFilterFunctionWhereInSchema,
   DbFilterFunctionWhereNullSchema,
   DbFilterMetadataFilteringSchema,
-  import_zod.default.object({
+  import_zod.z.object({
     function: DbFilterFunctionBasicSchema,
-    inner: import_zod.default.lazy(() => DbFilterSchema.array())
+    inner: import_zod.z.lazy(() => DbFilterSchema.array())
   })
 ]);
-var DbFilterInnerSchema = import_zod.default.object({
+var DbFilterInnerSchema = import_zod.z.object({
   function: DbFilterFunctionBasicSchema,
   inner: DbFilterSchema.array()
 });
-var DbFilterFunctionAllSchema = import_zod.default.union([
+var DbFilterFunctionAllSchema = import_zod.z.union([
   DbFilterFunctionBasicSchema,
   DbFilterFunctionInSchema,
   DbFilterFunctionNullSchema,
@@ -927,16 +917,16 @@ var DbFilterFunctionAllSchema = import_zod.default.union([
   DbFilterFunctionMetadataInSchema,
   DbFilterFunctionMetadataNullSchema
 ]);
-var DbFilterShapeSchema = import_zod.default.object({
+var DbFilterShapeSchema = import_zod.z.object({
   function: DbFilterFunctionAllSchema,
   field: DbFilterAllowedKeySchema.optional(),
   operator: DbFilterOperatorExtendedSchema.optional(),
-  value: import_zod.default.unknown().optional(),
-  inner: import_zod.default.unknown().array().optional()
+  value: import_zod.z.unknown().optional(),
+  inner: import_zod.z.unknown().array().optional()
 });
-var DbFilterInnerGenericSchema = import_zod.default.object({
+var DbFilterInnerGenericSchema = import_zod.z.object({
   function: DbFilterFunctionBasicSchema,
-  inner: import_zod.default.unknown().array()
+  inner: import_zod.z.unknown().array()
 });
 function validateSchema(data, schema, ctx) {
   const validation = schema.safeParse(data);
@@ -952,7 +942,7 @@ function validateSchema(data, schema, ctx) {
 function getDbFilter(objectInputSchema, schema) {
   const InSideSchema = schema.required();
   const FieldsSchema = InSideSchema.keyof();
-  const ObjectFilterSchema = import_zod.default.object({
+  const ObjectFilterSchema = import_zod.z.object({
     function: DbFilterFunctionBasicSchema,
     value: objectInputSchema
   });
@@ -1005,7 +995,7 @@ function getDbFilter(objectInputSchema, schema) {
       }
     }
   };
-  return import_zod.default.record(DbFilterAllowedKeySchema, import_zod.default.unknown()).superRefine((data, ctx) => {
+  return import_zod.z.record(DbFilterAllowedKeySchema, import_zod.z.unknown()).superRefine((data, ctx) => {
     if (!data.function) {
       return validateSchema(data, objectInputSchema, ctx);
     }

package/dist/db/consts.d.ts

@@ -1,5 +1,5 @@
 import { ForeignFilter, IdentifierFilter } from '../txs/consts.enums';
-import z from 'zod';
+import { z } from '../lib/zod';
 export type Metadata = {
     [key: string]: string | boolean | number | null | Metadata | undefined | (string | boolean | number | null | Metadata | undefined)[];
 } | null;

package/dist/db/consts.enums.d.ts

@@ -3,7 +3,7 @@ import { TransferTableType, TransferTableStatus } from './transfer/transfer.enum
 import { TransferGroupTableType, TransferGroupTableStatus } from './transfer-group/transfer-group.enums';
 import { WalletTableType, WalletTableStatus } from './wallet/wallet.enums';
 import { WapiSettingTableType } from './wapi-setting/wapi-setting.enums';
-import z from 'zod';
+import { z } from '../lib/zod';
 import { DatetimeSchema, DbFilterAllowedKeySchema, DbFilterAllowedValueOrMetadataSchema, DbFilterAllowedValueSchema, DbFilterForeignSchema, DbFilterFunctionAllSchema, DbFilterFunctionBasicSchema, DbFilterFunctionInSchema, DbFilterFunctionMetadataBasicSchema, DbFilterFunctionMetadataInSchema, DbFilterFunctionMetadataNullSchema, DbFilterFunctionNullSchema, DbFilterFunctionWhereForeignAllowedSchema, DbFilterFunctionWhereIdentifierAllowedSchema, DbFilterFunctionWhereInSchema, DbFilterFunctionWhereMetadataInSchema, DbFilterFunctionWhereMetadataNullSchema, DbFilterFunctionWhereMetadataPrimitiveSchema, DbFilterFunctionWhereNullSchema, DbFilterFunctionWhereObjectSchema, DbFilterFunctionWherePrimitiveForeignSchema, DbFilterFunctionWherePrimitiveIdentifierSchema, DbFilterFunctionWherePrimitiveObjectSchema, DbFilterFunctionWherePrimitiveSchema, DbFilterIdentifierSchema, DbFilterInnerGenericSchema, DbFilterInnerSchema, DbFilterMetadataFilteringSchema, DbFilterMetadataObjectSchema, DbFilterMetadataSchema, DbFilterOperatorAllSchema, DbFilterOperatorBasicSchema, DbFilterOperatorEqualsSchema, DbFilterOperatorExtendedSchema, DbFilterOperatorForNumbersSchema, DbFilterOperatorForStringsSchema, DbFilterOperatorStringSchema, DbFilterSchema, DbFilterShapeSchema, DbFilterStringNumberArraySchema, DbModelNameSchema, DbTimezone, flagsSchema } from './consts';
 export type Datetime = z.infer<typeof DatetimeSchema>;
 export type DbFilterAllowedKey = z.infer<typeof DbFilterAllowedKeySchema>;

package/dist/db/consts.js

@@ -20,7 +20,7 @@ var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 
 // src/db/consts.ts
 import { createEnumFromTuple } from "../lib/ts-utils";
-import z from "zod";
+import { z } from "../lib/zod";
 var MetadataSchema = z.record(
   z.string(),
   z.union([

package/dist/db/index.browser.cjs

@@ -21,17 +21,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var db_exports = {};
 __export(db_exports, {
   TokenStatusEnum: () => import_token_schema.TokenStatusEnum,
-  TokenTable: () => import_token.TokenTable,
   TokenTypeEnum: () => import_token_schema.TokenTypeEnum,
   TransferGroupStatusEnum: () => import_transfer_group_schema.TransferGroupStatusEnum,
-  TransferGroupTable: () => import_transfer_group.TransferGroupTable,
   TransferGroupTypeEnum: () => import_transfer_group_schema.TransferGroupTypeEnum,
-  TransferLogTable: () => import_transfer_log.TransferLogTable,
   TransferStatusEnum: () => import_transfer_schema.TransferStatusEnum,
-  TransferTable: () => import_transfer.TransferTable,
   TransferTypeEnum: () => import_transfer_schema.TransferTypeEnum,
   WalletStatusEnum: () => import_wallet_schema.WalletStatusEnum,
-  WalletTable: () => import_wallet.WalletTable,
   WalletTypeEnum: () => import_wallet_schema.WalletTypeEnum,
   WapiSettingTypeEnum: () => import_wapi_setting_schema.WapiSettingTypeEnum
 });
@@ -41,8 +36,3 @@ var import_transfer_schema = require('./transfer/transfer.schema.zod.cjs');
 var import_transfer_group_schema = require('./transfer-group/transfer-group.schema.zod.cjs');
 var import_wallet_schema = require('./wallet/wallet.schema.zod.cjs');
 var import_wapi_setting_schema = require('./wapi-setting/wapi-setting.schema.zod.cjs');
-var import_token = require('./token/token.enums.cjs');
-var import_transfer = require('./transfer/transfer.enums.cjs');
-var import_transfer_group = require('./transfer-group/transfer-group.enums.cjs');
-var import_transfer_log = require('./transfer-log/transfer-log.enums.cjs');
-var import_wallet = require('./wallet/wallet.enums.cjs');

package/dist/db/index.browser.js

@@ -10,24 +10,14 @@ import {
 } from "./transfer-group/transfer-group.schema.zod.browser.js";
 import { WalletStatusEnum, WalletTypeEnum } from "./wallet/wallet.schema.zod.browser.js";
 import { WapiSettingTypeEnum } from "./wapi-setting/wapi-setting.schema.zod.browser.js";
-import { TokenTable } from "./token/token.enums.browser.js";
-import { TransferTable } from "./transfer/transfer.enums.browser.js";
-import { TransferGroupTable } from "./transfer-group/transfer-group.enums.browser.js";
-import { TransferLogTable } from "./transfer-log/transfer-log.enums.browser.js";
-import { WalletTable } from "./wallet/wallet.enums.browser.js";
 export {
   TokenStatusEnum,
-  TokenTable,
   TokenTypeEnum,
   TransferGroupStatusEnum,
-  TransferGroupTable,
   TransferGroupTypeEnum,
-  TransferLogTable,
   TransferStatusEnum,
-  TransferTable,
   TransferTypeEnum,
   WalletStatusEnum,
-  WalletTable,
   WalletTypeEnum,
   WapiSettingTypeEnum
 };

package/dist/db/index.cjs

@@ -21,17 +21,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var db_exports = {};
 __export(db_exports, {
   TokenStatusEnum: () => import_token_schema.TokenStatusEnum,
-  TokenTable: () => import_token.TokenTable,
   TokenTypeEnum: () => import_token_schema.TokenTypeEnum,
   TransferGroupStatusEnum: () => import_transfer_group_schema.TransferGroupStatusEnum,
-  TransferGroupTable: () => import_transfer_group.TransferGroupTable,
   TransferGroupTypeEnum: () => import_transfer_group_schema.TransferGroupTypeEnum,
-  TransferLogTable: () => import_transfer_log.TransferLogTable,
   TransferStatusEnum: () => import_transfer_schema.TransferStatusEnum,
-  TransferTable: () => import_transfer.TransferTable,
   TransferTypeEnum: () => import_transfer_schema.TransferTypeEnum,
   WalletStatusEnum: () => import_wallet_schema.WalletStatusEnum,
-  WalletTable: () => import_wallet.WalletTable,
   WalletTypeEnum: () => import_wallet_schema.WalletTypeEnum,
   WapiSettingTypeEnum: () => import_wapi_setting_schema.WapiSettingTypeEnum
 });
@@ -41,25 +36,15 @@ var import_transfer_schema = require('./transfer/transfer.schema.zod.cjs');
 var import_transfer_group_schema = require('./transfer-group/transfer-group.schema.zod.cjs');
 var import_wallet_schema = require('./wallet/wallet.schema.zod.cjs');
 var import_wapi_setting_schema = require('./wapi-setting/wapi-setting.schema.zod.cjs');
-var import_token = require('./token/token.enums.cjs');
-var import_transfer = require('./transfer/transfer.enums.cjs');
-var import_transfer_group = require('./transfer-group/transfer-group.enums.cjs');
-var import_transfer_log = require('./transfer-log/transfer-log.enums.cjs');
-var import_wallet = require('./wallet/wallet.enums.cjs');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   TokenStatusEnum,
-  TokenTable,
   TokenTypeEnum,
   TransferGroupStatusEnum,
-  TransferGroupTable,
   TransferGroupTypeEnum,
-  TransferLogTable,
   TransferStatusEnum,
-  TransferTable,
   TransferTypeEnum,
   WalletStatusEnum,
-  WalletTable,
   WalletTypeEnum,
   WapiSettingTypeEnum
 });

package/dist/db/index.d.ts

@@ -1,10 +1,15 @@
-export { TokenStatusEnum, TokenTypeEnum } from './token/token.schema.zod';
-export { TransferStatusEnum, TransferTypeEnum, } from './transfer/transfer.schema.zod';
-export { TransferGroupStatusEnum, TransferGroupTypeEnum, } from './transfer-group/transfer-group.schema.zod';
-export { WalletStatusEnum, WalletTypeEnum } from './wallet/wallet.schema.zod';
-export { WapiSettingTypeEnum } from './wapi-setting/wapi-setting.schema.zod';
-export { TokenTable } from './token/token.enums';
-export { TransferTable } from './transfer/transfer.enums';
-export { TransferGroupTable } from './transfer-group/transfer-group.enums';
-export { TransferLogTable } from './transfer-log/transfer-log.enums';
-export { WalletTable } from './wallet/wallet.enums';
+import { TokenStatusEnum, TokenTypeEnum } from './token/token.schema.zod';
+export { TokenStatusEnum, TokenTypeEnum };
+import { TransferStatusEnum, TransferTypeEnum } from './transfer/transfer.schema.zod';
+export { TransferStatusEnum, TransferTypeEnum };
+import { TransferGroupStatusEnum, TransferGroupTypeEnum } from './transfer-group/transfer-group.schema.zod';
+export { TransferGroupStatusEnum, TransferGroupTypeEnum };
+import { WalletStatusEnum, WalletTypeEnum } from './wallet/wallet.schema.zod';
+export { WalletStatusEnum, WalletTypeEnum };
+import { WapiSettingTypeEnum } from './wapi-setting/wapi-setting.schema.zod';
+export { WapiSettingTypeEnum };
+export type { TokenTable } from './token/token.enums';
+export type { TransferTable } from './transfer/transfer.enums';
+export type { TransferGroupTable } from './transfer-group/transfer-group.enums';
+export type { WalletTable } from './wallet/wallet.enums';
+export type { TransferLogTable } from './transfer-log/transfer-log.enums';

package/dist/db/index.js

@@ -10,24 +10,14 @@ import {
 } from "./transfer-group/transfer-group.schema.zod";
 import { WalletStatusEnum, WalletTypeEnum } from "./wallet/wallet.schema.zod";
 import { WapiSettingTypeEnum } from "./wapi-setting/wapi-setting.schema.zod";
-import { TokenTable } from "./token/token.enums";
-import { TransferTable } from "./transfer/transfer.enums";
-import { TransferGroupTable } from "./transfer-group/transfer-group.enums";
-import { TransferLogTable } from "./transfer-log/transfer-log.enums";
-import { WalletTable } from "./wallet/wallet.enums";
 export {
   TokenStatusEnum,
-  TokenTable,
   TokenTypeEnum,
   TransferGroupStatusEnum,
-  TransferGroupTable,
   TransferGroupTypeEnum,
-  TransferLogTable,
   TransferStatusEnum,
-  TransferTable,
   TransferTypeEnum,
   WalletStatusEnum,
-  WalletTable,
   WalletTypeEnum,
   WapiSettingTypeEnum
 };

package/dist/db/token/token.enums.d.ts

@@ -1,7 +1,7 @@
 /**
  * This file is generated on build
  */
-import z from 'zod';
+import { z } from '../../lib/zod';
 import { tokenTableSchema, tokenTableStatusSchema, tokenTableTypeSchema } from './token.schema.zod';
 export type TokenTable = z.infer<typeof tokenTableSchema>;
 export type TokenTableStatus = z.infer<typeof tokenTableStatusSchema>;