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

package/dist/txs/consts.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,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/txs/consts.ts
@@ -73,59 +63,59 @@ __export(consts_exports, {
 module.exports = __toCommonJS(consts_exports);
 var import_consts = require('../db/consts.cjs');
 var import_ts_utils = require('../lib/ts-utils.cjs');
-var import_zod = __toESM(require("zod"), 1);
-var stringNumberToString = import_zod.default.union([import_zod.default.string(), import_zod.default.number()]).transform((strNr) => String(strNr));
-var stringNumberToInteger = import_zod.default.union([
-  import_zod.default.string().regex(/^[1-9][0-9]*$/, "invalid integer"),
-  import_zod.default.number().int().positive()
+var import_zod = require('../lib/zod.cjs');
+var stringNumberToString = import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).transform((strNr) => String(strNr));
+var stringNumberToInteger = import_zod.z.union([
+  import_zod.z.string().regex(/^[1-9][0-9]*$/, "invalid integer"),
+  import_zod.z.number().int().positive()
 ]).transform((strNr) => Number(strNr));
-var stringNumberToNumber = import_zod.default.union([
-  import_zod.default.string().regex(/^-{0,1}((0\.\d+)|([1-9]\d*(\.\d+){0,1}))$/, "invalid number"),
-  import_zod.default.number()
+var stringNumberToNumber = import_zod.z.union([
+  import_zod.z.string().regex(/^-{0,1}((0\.\d+)|([1-9]\d*(\.\d+){0,1}))$/, "invalid number"),
+  import_zod.z.number()
 ]).transform((strNr) => parseFloat(String(strNr)));
-var iTxTrackingOptions = import_zod.default.object({
-  tracking_id: import_zod.default.string().max(64).describe("User provided id added to logs for debugging")
+var iTxTrackingOptions = import_zod.z.object({
+  tracking_id: import_zod.z.string().max(64).describe("User provided id added to logs for debugging")
 }).describe("Tracking flags for input");
 var iTxGeneralOptions = iTxTrackingOptions.extend({
-  transaction_id: import_zod.default.string().max(64).describe("Id of the transaction context to run the query in")
+  transaction_id: import_zod.z.string().max(64).describe("Id of the transaction context to run the query in")
 }).describe("Generic flags for input");
-var iTxLimitingOptions = import_zod.default.object({
-  limit: import_zod.default.number().int().nonnegative().default(20).describe("Number of records to return"),
-  offset: import_zod.default.number().int().nonnegative().default(0).describe("Number of records to omit from the beginning")
+var iTxLimitingOptions = import_zod.z.object({
+  limit: import_zod.z.number().int().nonnegative().default(20).describe("Number of records to return"),
+  offset: import_zod.z.number().int().nonnegative().default(0).describe("Number of records to omit from the beginning")
 }).describe("Optional flags for input limiting");
-var iTxMetadataOptions = import_zod.default.object({
-  return_metadata_total: import_zod.default.boolean().describe("Return the total rows count in metadata")
+var iTxMetadataOptions = import_zod.z.object({
+  return_metadata_total: import_zod.z.boolean().describe("Return the total rows count in metadata")
 }).describe("Metadata flags for input");
-var iTxOrderingDirection = import_zod.default.enum(["asc", "desc"]).describe("Direction to order");
-var iTxNullsOrderingDirection = import_zod.default.enum(["first", "last"]).describe("Should nulls be first or last");
-var iTxOrderingInput = import_zod.default.object({
-  field: import_zod.default.string().describe("Field to order by"),
+var iTxOrderingDirection = import_zod.z.enum(["asc", "desc"]).describe("Direction to order");
+var iTxNullsOrderingDirection = import_zod.z.enum(["first", "last"]).describe("Should nulls be first or last");
+var iTxOrderingInput = import_zod.z.object({
+  field: import_zod.z.string().describe("Field to order by"),
   direction: iTxOrderingDirection.default("asc"),
   nulls: iTxNullsOrderingDirection
 }).strict().partial().required({
   field: true
 }).describe("Input for orderBy");
-var iTxOrderingOptions = import_zod.default.object({
+var iTxOrderingOptions = import_zod.z.object({
   order: iTxOrderingInput.array().describe("Ordering options")
 }).describe("Optional flags for input ordering");
-var idForeignSubFilter = import_zod.default.object({
-  id: import_zod.default.number().int().positive().describe("id of the object"),
-  foreign: import_zod.default.string().max(255).describe("foreign of the object")
+var idForeignSubFilter = import_zod.z.object({
+  id: import_zod.z.number().int().positive().describe("id of the object"),
+  foreign: import_zod.z.string().max(255).describe("foreign of the object")
 }).strict().partial();
-var foreignFilter = import_zod.default.union([
+var foreignFilter = import_zod.z.union([
   idForeignSubFilter.required({ id: true }),
   idForeignSubFilter.required({ foreign: true })
 ]);
-var idIdentifierSubFilter = import_zod.default.object({
-  id: import_zod.default.number().int().positive().describe("id of the object"),
-  identifier: import_zod.default.string().max(255).describe("identifier of the object")
+var idIdentifierSubFilter = import_zod.z.object({
+  id: import_zod.z.number().int().positive().describe("id of the object"),
+  identifier: import_zod.z.string().max(255).describe("identifier of the object")
 }).strict().partial();
-var identifierFilter = import_zod.default.union([
+var identifierFilter = import_zod.z.union([
   idIdentifierSubFilter.required({ id: true }),
   idIdentifierSubFilter.required({ identifier: true })
 ]);
-var iTxMetadataAction = import_zod.default.enum(["replace", "extend"]).default("replace").describe("Whether to replace or extend current metadata with new value");
-var iTxMetadataActionForReverse = import_zod.default.enum([
+var iTxMetadataAction = import_zod.z.enum(["replace", "extend"]).default("replace").describe("Whether to replace or extend current metadata with new value");
+var iTxMetadataActionForReverse = import_zod.z.enum([
   "replace",
   "replace_create_only",
   "replace_cancel_only",
@@ -133,15 +123,15 @@ var iTxMetadataActionForReverse = import_zod.default.enum([
   "extend_create_only",
   "extend_cancel_only"
 ]).default("replace").describe("Whether to replace or extend current metadata with new value");
-var iTxDistributorLeftoverRule = import_zod.default.enum(["keep", "random", "largest", "target"]).describe("Rule for distribution grouping");
+var iTxDistributorLeftoverRule = import_zod.z.enum(["keep", "random", "largest", "target"]).describe("Rule for distribution grouping");
 var ITxDistributorLeftoverRuleEnum = (0, import_ts_utils.createEnumFromTuple)(
   iTxDistributorLeftoverRule.options
 );
-var iTxFindMetadata = import_zod.default.object({
-  total: import_zod.default.number().int().nonnegative().describe("Total number of records matching the query"),
-  offset: import_zod.default.number().int().nonnegative().describe("Current query offset"),
-  limit: import_zod.default.number().int().nonnegative().describe("Current query limit"),
-  more_rows: import_zod.default.boolean().describe(
+var iTxFindMetadata = import_zod.z.object({
+  total: import_zod.z.number().int().nonnegative().describe("Total number of records matching the query"),
+  offset: import_zod.z.number().int().nonnegative().describe("Current query offset"),
+  limit: import_zod.z.number().int().nonnegative().describe("Current query limit"),
+  more_rows: import_zod.z.boolean().describe(
     "Boolean showing if there would be more rows to return with a higher offset/limit"
   ),
   order: iTxOrderingInput.array()
@@ -150,74 +140,74 @@ var iTxFindMetadata = import_zod.default.object({
   limit: true,
   more_rows: true
 }).describe("Metadata about the search");
-var iTxAggregatorSimple = import_zod.default.enum(["count", "countDistinct", "sum", "average", "min", "max"]).default("count").describe("Function to use for grouping");
-var iTxAggregatorComplex = import_zod.default.object({
+var iTxAggregatorSimple = import_zod.z.enum(["count", "countDistinct", "sum", "average", "min", "max"]).default("count").describe("Function to use for grouping");
+var iTxAggregatorComplex = import_zod.z.object({
   function: iTxAggregatorSimple,
   field: import_consts.DbFilterAllowedKeySchema.describe("Field to group by"),
   alias: import_consts.DbFilterAllowedKeySchema.describe("Alias to group under")
 }).partial().describe("Function and field to group");
-var iTxAggregator = import_zod.default.union([iTxAggregatorSimple, iTxAggregatorComplex]).describe("Aggregator description");
-var iTxPeriodSimple = import_zod.default.enum(["year", "month", "week", "day", "hour", "minute"]).describe("Time period rows should be grouped by");
+var iTxAggregator = import_zod.z.union([iTxAggregatorSimple, iTxAggregatorComplex]).describe("Aggregator description");
+var iTxPeriodSimple = import_zod.z.enum(["year", "month", "week", "day", "hour", "minute"]).describe("Time period rows should be grouped by");
 var ITxPeriodSimpleEnum = (0, import_ts_utils.createEnumFromTuple)(iTxPeriodSimple.options);
-var iTxPeriodTimezone = import_zod.default.object({
+var iTxPeriodTimezone = import_zod.z.object({
   period: iTxPeriodSimple.default("day"),
   timezone: import_consts.DbTimezone
 }).strict().required();
-var iTxPeriod = import_zod.default.union([iTxPeriodSimple, iTxPeriodTimezone]);
-var iTxGroupPeriod = import_zod.default.object({
-  type: import_zod.default.literal("period"),
+var iTxPeriod = import_zod.z.union([iTxPeriodSimple, iTxPeriodTimezone]);
+var iTxGroupPeriod = import_zod.z.object({
+  type: import_zod.z.literal("period"),
   field: iTxPeriod,
-  alias: import_zod.default.string()
+  alias: import_zod.z.string()
 }).strict().partial().required({
   type: true,
   field: true
 });
-var iTxGroupField = import_zod.default.object({
-  type: import_zod.default.literal("field"),
-  field: import_zod.default.string(),
-  alias: import_zod.default.string()
+var iTxGroupField = import_zod.z.object({
+  type: import_zod.z.literal("field"),
+  field: import_zod.z.string(),
+  alias: import_zod.z.string()
 }).strict().partial().required({
   type: true,
   field: true
 });
-var iTxGroupMetadataField = import_zod.default.object({
-  type: import_zod.default.literal("metadata_field"),
-  field: import_zod.default.string(),
-  alias: import_zod.default.string()
+var iTxGroupMetadataField = import_zod.z.object({
+  type: import_zod.z.literal("metadata_field"),
+  field: import_zod.z.string(),
+  alias: import_zod.z.string()
 }).strict().partial().required({
   type: true,
   field: true
 });
-var iTxGroup = import_zod.default.discriminatedUnion("type", [
+var iTxGroup = import_zod.z.discriminatedUnion("type", [
   iTxGroupPeriod,
   iTxGroupField,
   iTxGroupMetadataField
 ]);
 function getGroupingGroup(fields) {
-  return import_zod.default.discriminatedUnion("type", [
+  return import_zod.z.discriminatedUnion("type", [
     iTxGroupPeriod,
     iTxGroupField.extend({
-      field: import_zod.default.enum(fields)
+      field: import_zod.z.enum(fields)
     }),
     iTxGroupMetadataField
   ]);
 }
 var iTxGroups = iTxGroup.array().max(5);
-var iTxAggregateResult = import_zod.default.record(import_zod.default.string(), import_zod.default.union([import_zod.default.string(), import_zod.default.number()]).nullable()).describe("Result of the aggregation");
+var iTxAggregateResult = import_zod.z.record(import_zod.z.string(), import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).nullable()).describe("Result of the aggregation");
 var iTxAggregateResults = iTxAggregateResult.array().describe("Results of the aggregation");
-var iTxAggregatingMetadata = import_zod.default.object({
+var iTxAggregatingMetadata = import_zod.z.object({
   aggregators: iTxAggregator.array(),
   groups: iTxGroups
 }).partial().required({
   groups: true
 }).describe("Metadata about the aggregation");
-var iTxSelectOptions = import_zod.default.object({
-  select: import_zod.default.string().array()
+var iTxSelectOptions = import_zod.z.object({
+  select: import_zod.z.string().array()
 }).describe("Optional flags to select specific fields");
-var iTxDeselectOptions = import_zod.default.object({
-  deselect: import_zod.default.string().array()
+var iTxDeselectOptions = import_zod.z.object({
+  deselect: import_zod.z.string().array()
 }).describe('Optional flag to remove field from select"');
-var iTxTimeFilter = import_zod.default.object({
+var iTxTimeFilter = import_zod.z.object({
   start_time: import_consts.DatetimeSchema,
   end_time: import_consts.DatetimeSchema
 }).partial().strict();

package/dist/txs/consts.d.ts

@@ -1,4 +1,4 @@
-import z from 'zod';
+import { z } from '../lib/zod';
 export declare const stringNumberToString: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, string, string | number>;
 export declare const stringNumberToInteger: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>;
 export declare const stringNumberToNumber: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>;
@@ -9,11 +9,11 @@ export declare const iTxTrackingOptions: z.ZodObject<{
 }, {
     tracking_id: string;
 }>;
-export declare const iTxGeneralOptions: z.ZodObject<z.objectUtil.extendShape<{
+export declare const iTxGeneralOptions: z.ZodObject<{
     tracking_id: z.ZodString;
-}, {
+} & {
     transaction_id: z.ZodString;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     tracking_id: string;
     transaction_id: string;
 }, {
@@ -374,37 +374,32 @@ export declare function getGroupingGroup<Fields extends [string, ...string[]]>(f
         period?: "year" | "month" | "week" | "day" | "hour" | "minute" | undefined;
     };
     alias?: string | undefined;
-}>, z.ZodObject<z.objectUtil.extendShape<{
+}>, z.ZodObject<{
     type: z.ZodLiteral<"field">;
-    field: z.ZodString;
     alias: z.ZodOptional<z.ZodString>;
-}, {
+} & {
     field: z.ZodEnum<z.Writeable<Fields>>;
-}>, "strict", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<z.objectUtil.extendShape<{
+}, "strict", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
     type: z.ZodLiteral<"field">;
-    field: z.ZodString;
     alias: z.ZodOptional<z.ZodString>;
-}, {
+} & {
     field: z.ZodEnum<z.Writeable<Fields>>;
-}>>, any> extends infer T ? { [k in keyof T]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<z.objectUtil.extendShape<{
+}>, any> extends infer T ? { [k in keyof T]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
     type: z.ZodLiteral<"field">;
-    field: z.ZodString;
     alias: z.ZodOptional<z.ZodString>;
-}, {
+} & {
     field: z.ZodEnum<z.Writeable<Fields>>;
-}>>, any>[k]; } : never, z.baseObjectInputType<z.objectUtil.extendShape<{
+}>, any>[k]; } : never, z.baseObjectInputType<{
     type: z.ZodLiteral<"field">;
-    field: z.ZodString;
     alias: z.ZodOptional<z.ZodString>;
-}, {
+} & {
     field: z.ZodEnum<z.Writeable<Fields>>;
-}>> extends infer T_1 ? { [k_1 in keyof T_1]: z.baseObjectInputType<z.objectUtil.extendShape<{
+}> extends infer T_1 ? { [k_1 in keyof T_1]: z.baseObjectInputType<{
     type: z.ZodLiteral<"field">;
-    field: z.ZodString;
     alias: z.ZodOptional<z.ZodString>;
-}, {
+} & {
     field: z.ZodEnum<z.Writeable<Fields>>;
-}>>[k_1]; } : never>, z.ZodObject<{
+}>[k_1]; } : never>, z.ZodObject<{
     type: z.ZodLiteral<"metadata_field">;
     field: z.ZodString;
     alias: z.ZodOptional<z.ZodString>;

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

@@ -1,4 +1,4 @@
-import z from 'zod';
+import { z } from '../lib/zod';
 import { foreignFilter, iTxAggregateResult, iTxAggregateResults, iTxAggregatingMetadata, iTxAggregator, iTxAggregatorComplex, iTxAggregatorSimple, iTxDeselectOptions, iTxDistributorLeftoverRule, iTxFindMetadata, iTxGeneralOptions, iTxGroup, iTxGroupField, iTxGroupMetadataField, iTxGroupPeriod, iTxGroups, iTxLimitingOptions, iTxMetadataAction, iTxMetadataActionForReverse, iTxMetadataOptions, iTxNullsOrderingDirection, iTxOrderingDirection, iTxOrderingInput, iTxOrderingOptions, iTxPeriod, iTxPeriodSimple, iTxPeriodTimezone, iTxSelectOptions, iTxTimeFilter, iTxTrackingOptions, idForeignSubFilter, idIdentifierSubFilter, identifierFilter, stringNumberToInteger, stringNumberToNumber, stringNumberToString } from './consts';
 export type ForeignFilter = z.infer<typeof foreignFilter>;
 export type ITxAggregateResult = z.infer<typeof iTxAggregateResult>;

package/dist/txs/consts.js

@@ -5,7 +5,7 @@ import {
   DbTimezone
 } from "../db/consts";
 import { createEnumFromTuple } from "../lib/ts-utils";
-import z from "zod";
+import { z } from "../lib/zod";
 var stringNumberToString = z.union([z.string(), z.number()]).transform((strNr) => String(strNr));
 var stringNumberToInteger = z.union([
   z.string().regex(/^[1-9][0-9]*$/, "invalid integer"),

package/dist/txs/create-access-token/create-access-token.enums.d.ts

@@ -1,7 +1,7 @@
 /**
  * This file is generated on build
  */
-import z from 'zod';
+import { z } from '../../lib/zod';
 import { createAccessTokenAdmin, createAccessTokenForcedFiltersSchema, createAccessTokenLimited, createAccessTokenLimitedScopesSchema, createAccessTokenTxInputOptionsSchema, createAccessTokenTxInputSchema, createAccessTokenTxOutputSchema } from './create-access-token.schema.zod';
 export type CreateAccessTokenAdmin = z.infer<typeof createAccessTokenAdmin>;
 export type CreateAccessTokenForcedFilters = z.infer<typeof createAccessTokenForcedFiltersSchema>;