wapi-client 0.12.5-beta.6 → 0.13.0

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/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>;