wapi-client 0.18.0-beta.3 → 0.18.0-beta.5

package/dist/txs/consts.browser.cjs

@@ -1,290 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/txs/consts.ts
-var consts_exports = {};
-__export(consts_exports, {
-  ITxDistributorLeftoverRuleEnum: () => ITxDistributorLeftoverRuleEnum,
-  ITxPeriodSimpleEnum: () => ITxPeriodSimpleEnum,
-  foreignFilter: () => foreignFilter,
-  getGroupingGroup: () => getGroupingGroup,
-  iTxAggregateResult: () => iTxAggregateResult,
-  iTxAggregateResults: () => iTxAggregateResults,
-  iTxAggregatingMetadata: () => iTxAggregatingMetadata,
-  iTxAggregator: () => iTxAggregator,
-  iTxAggregatorComplex: () => iTxAggregatorComplex,
-  iTxAggregatorSimple: () => iTxAggregatorSimple,
-  iTxDeselectOptions: () => iTxDeselectOptions,
-  iTxDistributorLeftoverRule: () => iTxDistributorLeftoverRule,
-  iTxFindMetadata: () => iTxFindMetadata,
-  iTxFunctionNames: () => iTxFunctionNames,
-  iTxGeneralOptions: () => iTxGeneralOptions,
-  iTxGroup: () => iTxGroup,
-  iTxGroupField: () => iTxGroupField,
-  iTxGroupMetadataField: () => iTxGroupMetadataField,
-  iTxGroupPeriod: () => iTxGroupPeriod,
-  iTxGroups: () => iTxGroups,
-  iTxLimitingOptions: () => iTxLimitingOptions,
-  iTxMetadataAction: () => iTxMetadataAction,
-  iTxMetadataActionForReverse: () => iTxMetadataActionForReverse,
-  iTxMetadataOptions: () => iTxMetadataOptions,
-  iTxNullsOrderingDirection: () => iTxNullsOrderingDirection,
-  iTxOrderingDirection: () => iTxOrderingDirection,
-  iTxOrderingInput: () => iTxOrderingInput,
-  iTxOrderingOptions: () => iTxOrderingOptions,
-  iTxPeriod: () => iTxPeriod,
-  iTxPeriodSimple: () => iTxPeriodSimple,
-  iTxPeriodTimezone: () => iTxPeriodTimezone,
-  iTxSelectOptions: () => iTxSelectOptions,
-  iTxTimeFilter: () => iTxTimeFilter,
-  iTxTrackingOptions: () => iTxTrackingOptions,
-  idForeignSubFilter: () => idForeignSubFilter,
-  idIdentifierSubFilter: () => idIdentifierSubFilter,
-  identifierFilter: () => identifierFilter,
-  stringNumberToInteger: () => stringNumberToInteger,
-  stringNumberToNumber: () => stringNumberToNumber,
-  stringNumberToString: () => stringNumberToString
-});
-module.exports = __toCommonJS(consts_exports);
-var import_consts = require("../db/consts.browser.cjs");
-var import_ts_utils = require("../lib/ts-utils.browser.cjs");
-var import_zod = require("zod");
-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.z.union([
-  import_zod.z.string().regex(
-    /(^-{0,1}((0\.\d+)|([1-9]\d*(\.\d+){0,1}))$)|(^0$)/,
-    "invalid number"
-  ),
-  import_zod.z.number()
-]).transform((strNr) => parseFloat(String(strNr)));
-var iTxTrackingOptions = import_zod.z.object({
-  tracking_id: import_zod.z.string().max(64).optional().describe("User provided id added to logs for debugging")
-}).describe("Tracking flags for input");
-var iTxGeneralOptions = iTxTrackingOptions.extend({
-  transaction_id: import_zod.z.string().max(64).optional().describe("Id of the transaction context to run the query in")
-}).describe("Generic flags for input");
-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.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.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.z.object({
-  order: iTxOrderingInput.array().describe("Ordering options")
-}).describe("Optional flags for input ordering");
-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.z.union([
-  import_zod.z.string(),
-  import_zod.z.number(),
-  idForeignSubFilter.required({ id: true }),
-  idForeignSubFilter.required({ foreign: true })
-]).transform(
-  (foreign) => typeof foreign !== "object" ? { foreign: foreign + "" } : foreign
-);
-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.z.union([
-  import_zod.z.string(),
-  import_zod.z.number(),
-  idIdentifierSubFilter.required({ id: true }),
-  idIdentifierSubFilter.required({ identifier: true })
-]).transform(
-  (identifier) => typeof identifier !== "object" ? { identifier: identifier + "" } : identifier
-);
-var iTxMetadataAction = import_zod.z.enum(["replace", "extend"]).describe("Whether to replace or extend current metadata with new value");
-var iTxMetadataActionForReverse = import_zod.z.enum([
-  "replace",
-  "replace_create_only",
-  "replace_cancel_only",
-  "extend",
-  "extend_create_only",
-  "extend_cancel_only"
-]).describe("Whether to replace or extend current metadata with new value");
-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.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()
-}).partial().required({
-  offset: true,
-  limit: true,
-  more_rows: true
-}).describe("Metadata about the search");
-var iTxAggregatorSimple = import_zod.z.enum(["count", "countDistinct", "sum", "average", "min", "max"]).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.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.z.object({
-  period: iTxPeriodSimple.default("day"),
-  timezone: import_consts.DbTimezone
-}).strict().required();
-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.z.string()
-}).strict().partial().required({
-  type: true,
-  field: true
-});
-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.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.z.discriminatedUnion("type", [
-  iTxGroupPeriod,
-  iTxGroupField,
-  iTxGroupMetadataField
-]);
-function getGroupingGroup(fields) {
-  return import_zod.z.discriminatedUnion("type", [
-    iTxGroupPeriod,
-    iTxGroupField.extend({
-      field: import_zod.z.enum(fields)
-    }),
-    iTxGroupMetadataField
-  ]);
-}
-var iTxGroups = iTxGroup.array().max(5);
-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.z.object({
-  aggregators: iTxAggregator.array(),
-  groups: iTxGroups
-}).partial().required({
-  groups: true
-}).describe("Metadata about the aggregation");
-var iTxSelectOptions = import_zod.z.object({
-  select: import_zod.z.string().array()
-}).describe("Optional flags to select specific fields");
-var iTxDeselectOptions = import_zod.z.object({
-  deselect: import_zod.z.string().array()
-}).describe('Optional flag to remove field from select"');
-var iTxTimeFilter = import_zod.z.object({
-  start_time: import_consts.DatetimeSchema,
-  end_time: import_consts.DatetimeSchema
-}).partial().strict();
-var iTxFunctionNames = import_zod.z.enum([
-  // FNFUNCTIONS
-  /*
-   * THIS IS AUTOGENERATED, DO NOT EDIT MANUALLY
-   * if you need custom code add it outside this block
-   */
-  "aggregateTransferMany",
-  "authenticationCheck",
-  "createAccessToken",
-  "createApikey",
-  "createContract",
-  "createDeposit",
-  "createDistribution",
-  "createIndex",
-  "createToken",
-  "createTransfer",
-  "createTransferGroup",
-  "createTransferMany",
-  "createWallet",
-  "createWithdrawal",
-  "dropIndex",
-  "exportBalanceHistory",
-  "exportBalanceMany",
-  "exportTokenMany",
-  "exportTransferGroupMany",
-  "exportTransferMany",
-  "exportWalletMany",
-  "findApikeyMany",
-  "findBalanceMany",
-  "findIndexMany",
-  "findTokenMany",
-  "findTransferGroupMany",
-  "findTransferMany",
-  "findWalletMany",
-  "finishTransaction",
-  "getBalance",
-  "getBalanceHistory",
-  "getExport",
-  "getFlags",
-  "getStatistics",
-  "getToken",
-  "getTokenMany",
-  "getTransfer",
-  "getTransferGroup",
-  "getWallet",
-  "getWalletMany",
-  "healthcheck",
-  "listDatabaseExports",
-  "listExportMany",
-  "resetDatabase",
-  "reverseTransfer",
-  "reverseTransferGroup",
-  "reverseTransferGroupMany",
-  "reverseTransferMany",
-  "setFlags",
-  "startTransaction",
-  "updateApikey",
-  "updateToken",
-  "updateTransfer",
-  "updateTransferGroup",
-  "updateTransferGroupMany",
-  "updateTransferMany",
-  "updateWallet"
-  // FNFUNCTIONS
-]);

package/dist/txs/consts.browser.js

@@ -1,273 +0,0 @@
-// src/txs/consts.ts
-import {
-  DatetimeSchema,
-  DbFilterAllowedKeySchema,
-  DbTimezone
-} from "../db/consts.browser.js";
-import { createEnumFromTuple } from "../lib/ts-utils.browser.js";
-import { z } from "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"),
-  z.number().int().positive()
-]).transform((strNr) => Number(strNr));
-var stringNumberToNumber = z.union([
-  z.string().regex(
-    /(^-{0,1}((0\.\d+)|([1-9]\d*(\.\d+){0,1}))$)|(^0$)/,
-    "invalid number"
-  ),
-  z.number()
-]).transform((strNr) => parseFloat(String(strNr)));
-var iTxTrackingOptions = z.object({
-  tracking_id: z.string().max(64).optional().describe("User provided id added to logs for debugging")
-}).describe("Tracking flags for input");
-var iTxGeneralOptions = iTxTrackingOptions.extend({
-  transaction_id: z.string().max(64).optional().describe("Id of the transaction context to run the query in")
-}).describe("Generic flags for input");
-var iTxLimitingOptions = z.object({
-  limit: z.number().int().nonnegative().default(20).describe("Number of records to return"),
-  offset: z.number().int().nonnegative().default(0).describe("Number of records to omit from the beginning")
-}).describe("Optional flags for input limiting");
-var iTxMetadataOptions = z.object({
-  return_metadata_total: z.boolean().describe("Return the total rows count in metadata")
-}).describe("Metadata flags for input");
-var iTxOrderingDirection = z.enum(["asc", "desc"]).describe("Direction to order");
-var iTxNullsOrderingDirection = z.enum(["first", "last"]).describe("Should nulls be first or last");
-var iTxOrderingInput = z.object({
-  field: z.string().describe("Field to order by"),
-  direction: iTxOrderingDirection.default("asc"),
-  nulls: iTxNullsOrderingDirection
-}).strict().partial().required({
-  field: true
-}).describe("Input for orderBy");
-var iTxOrderingOptions = z.object({
-  order: iTxOrderingInput.array().describe("Ordering options")
-}).describe("Optional flags for input ordering");
-var idForeignSubFilter = z.object({
-  id: z.number().int().positive().describe("id of the object"),
-  foreign: z.string().max(255).describe("foreign of the object")
-}).strict().partial();
-var foreignFilter = z.union([
-  z.string(),
-  z.number(),
-  idForeignSubFilter.required({ id: true }),
-  idForeignSubFilter.required({ foreign: true })
-]).transform(
-  (foreign) => typeof foreign !== "object" ? { foreign: foreign + "" } : foreign
-);
-var idIdentifierSubFilter = z.object({
-  id: z.number().int().positive().describe("id of the object"),
-  identifier: z.string().max(255).describe("identifier of the object")
-}).strict().partial();
-var identifierFilter = z.union([
-  z.string(),
-  z.number(),
-  idIdentifierSubFilter.required({ id: true }),
-  idIdentifierSubFilter.required({ identifier: true })
-]).transform(
-  (identifier) => typeof identifier !== "object" ? { identifier: identifier + "" } : identifier
-);
-var iTxMetadataAction = z.enum(["replace", "extend"]).describe("Whether to replace or extend current metadata with new value");
-var iTxMetadataActionForReverse = z.enum([
-  "replace",
-  "replace_create_only",
-  "replace_cancel_only",
-  "extend",
-  "extend_create_only",
-  "extend_cancel_only"
-]).describe("Whether to replace or extend current metadata with new value");
-var iTxDistributorLeftoverRule = z.enum(["keep", "random", "largest", "target"]).describe("Rule for distribution grouping");
-var ITxDistributorLeftoverRuleEnum = createEnumFromTuple(
-  iTxDistributorLeftoverRule.options
-);
-var iTxFindMetadata = z.object({
-  total: z.number().int().nonnegative().describe("Total number of records matching the query"),
-  offset: z.number().int().nonnegative().describe("Current query offset"),
-  limit: z.number().int().nonnegative().describe("Current query limit"),
-  more_rows: z.boolean().describe(
-    "Boolean showing if there would be more rows to return with a higher offset/limit"
-  ),
-  order: iTxOrderingInput.array()
-}).partial().required({
-  offset: true,
-  limit: true,
-  more_rows: true
-}).describe("Metadata about the search");
-var iTxAggregatorSimple = z.enum(["count", "countDistinct", "sum", "average", "min", "max"]).describe("Function to use for grouping");
-var iTxAggregatorComplex = z.object({
-  function: iTxAggregatorSimple,
-  field: DbFilterAllowedKeySchema.describe("Field to group by"),
-  alias: DbFilterAllowedKeySchema.describe("Alias to group under")
-}).partial().describe("Function and field to group");
-var iTxAggregator = z.union([iTxAggregatorSimple, iTxAggregatorComplex]).describe("Aggregator description");
-var iTxPeriodSimple = z.enum(["year", "month", "week", "day", "hour", "minute"]).describe("Time period rows should be grouped by");
-var ITxPeriodSimpleEnum = createEnumFromTuple(iTxPeriodSimple.options);
-var iTxPeriodTimezone = z.object({
-  period: iTxPeriodSimple.default("day"),
-  timezone: DbTimezone
-}).strict().required();
-var iTxPeriod = z.union([iTxPeriodSimple, iTxPeriodTimezone]);
-var iTxGroupPeriod = z.object({
-  type: z.literal("period"),
-  field: iTxPeriod,
-  alias: z.string()
-}).strict().partial().required({
-  type: true,
-  field: true
-});
-var iTxGroupField = z.object({
-  type: z.literal("field"),
-  field: z.string(),
-  alias: z.string()
-}).strict().partial().required({
-  type: true,
-  field: true
-});
-var iTxGroupMetadataField = z.object({
-  type: z.literal("metadata_field"),
-  field: z.string(),
-  alias: z.string()
-}).strict().partial().required({
-  type: true,
-  field: true
-});
-var iTxGroup = z.discriminatedUnion("type", [
-  iTxGroupPeriod,
-  iTxGroupField,
-  iTxGroupMetadataField
-]);
-function getGroupingGroup(fields) {
-  return z.discriminatedUnion("type", [
-    iTxGroupPeriod,
-    iTxGroupField.extend({
-      field: z.enum(fields)
-    }),
-    iTxGroupMetadataField
-  ]);
-}
-var iTxGroups = iTxGroup.array().max(5);
-var iTxAggregateResult = z.record(z.string(), z.union([z.string(), z.number()]).nullable()).describe("Result of the aggregation");
-var iTxAggregateResults = iTxAggregateResult.array().describe("Results of the aggregation");
-var iTxAggregatingMetadata = z.object({
-  aggregators: iTxAggregator.array(),
-  groups: iTxGroups
-}).partial().required({
-  groups: true
-}).describe("Metadata about the aggregation");
-var iTxSelectOptions = z.object({
-  select: z.string().array()
-}).describe("Optional flags to select specific fields");
-var iTxDeselectOptions = z.object({
-  deselect: z.string().array()
-}).describe('Optional flag to remove field from select"');
-var iTxTimeFilter = z.object({
-  start_time: DatetimeSchema,
-  end_time: DatetimeSchema
-}).partial().strict();
-var iTxFunctionNames = z.enum([
-  // FNFUNCTIONS
-  /*
-   * THIS IS AUTOGENERATED, DO NOT EDIT MANUALLY
-   * if you need custom code add it outside this block
-   */
-  "aggregateTransferMany",
-  "authenticationCheck",
-  "createAccessToken",
-  "createApikey",
-  "createContract",
-  "createDeposit",
-  "createDistribution",
-  "createIndex",
-  "createToken",
-  "createTransfer",
-  "createTransferGroup",
-  "createTransferMany",
-  "createWallet",
-  "createWithdrawal",
-  "dropIndex",
-  "exportBalanceHistory",
-  "exportBalanceMany",
-  "exportTokenMany",
-  "exportTransferGroupMany",
-  "exportTransferMany",
-  "exportWalletMany",
-  "findApikeyMany",
-  "findBalanceMany",
-  "findIndexMany",
-  "findTokenMany",
-  "findTransferGroupMany",
-  "findTransferMany",
-  "findWalletMany",
-  "finishTransaction",
-  "getBalance",
-  "getBalanceHistory",
-  "getExport",
-  "getFlags",
-  "getStatistics",
-  "getToken",
-  "getTokenMany",
-  "getTransfer",
-  "getTransferGroup",
-  "getWallet",
-  "getWalletMany",
-  "healthcheck",
-  "listDatabaseExports",
-  "listExportMany",
-  "resetDatabase",
-  "reverseTransfer",
-  "reverseTransferGroup",
-  "reverseTransferGroupMany",
-  "reverseTransferMany",
-  "setFlags",
-  "startTransaction",
-  "updateApikey",
-  "updateToken",
-  "updateTransfer",
-  "updateTransferGroup",
-  "updateTransferGroupMany",
-  "updateTransferMany",
-  "updateWallet"
-  // FNFUNCTIONS
-]);
-export {
-  ITxDistributorLeftoverRuleEnum,
-  ITxPeriodSimpleEnum,
-  foreignFilter,
-  getGroupingGroup,
-  iTxAggregateResult,
-  iTxAggregateResults,
-  iTxAggregatingMetadata,
-  iTxAggregator,
-  iTxAggregatorComplex,
-  iTxAggregatorSimple,
-  iTxDeselectOptions,
-  iTxDistributorLeftoverRule,
-  iTxFindMetadata,
-  iTxFunctionNames,
-  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
-};