wapi-client 0.13.0 → 0.14.1

package/dist/lib/streams.d.ts

@@ -1,28 +0,0 @@
-/**
- * @internal
- */
-export declare class ReadStream {
-    private _data;
-    private _error;
-    private _end;
-    private _finished;
-    private _options;
-    constructor(options?: unknown);
-    on(type: 'data' | 'end' | 'error', fn: (data?: any) => void): this;
-    push(data: unknown): this;
-    error(err: unknown): this;
-    end(): this;
-    destroy(err: unknown): this;
-    get destroyed(): boolean;
-}
-export declare class ReadWriteStream<InputType> {
-    constructor();
-    pipe(..._args: unknown[]): ReadWriteStream<InputType>;
-    pause(): void;
-    resume(): void;
-    on(..._args: unknown[]): this;
-}
-export declare class TransformStream<Input, Output> {
-    constructor();
-    dataTransform(input?: Input): Promise<Output>;
-}

package/dist/lib/ts-utils.d.ts

@@ -1,3 +0,0 @@
-export declare function createEnumFromTuple<T extends readonly string[]>(tuple: T): Readonly<{
-    [K in T[number]]: K;
-}>;

package/dist/lib/utils.d.ts

@@ -1,55 +0,0 @@
-import { EWapiConnectionOptions } from '../api/ws-client';
-import { ITxOrderingInput } from '../txs/consts.enums';
-export declare function getRandomHex(length?: number): string;
-export declare function getTxIdSync(object?: {
-    [key: string]: unknown;
-}): string;
-export declare function wait(time: number): Promise<void>;
-/**
- * Generate UUID v4 to use as identifier
- */
-export declare function getIdentifier(): string;
-export declare function copyObject<T>(input: T): T;
-export declare function checkCopyObject<T>(input: T, property: string, value: unknown): T;
-type ForeignType = {
-    foreign: string;
-};
-export declare function getForeign(value: undefined): undefined;
-export declare function getForeign(value: number | string): ForeignType;
-export declare function getForeign(value: number | string | undefined): ForeignType | undefined;
-type IdentifierType = {
-    identifier: string;
-};
-export declare function getIdentifierFilter(value: undefined): undefined;
-export declare function getIdentifierFilter(value: number | string): IdentifierType;
-export declare function getIdentifierFilter(value: number | string | undefined): IdentifierType | undefined;
-export declare function inputToString(value: undefined | null | string | number): undefined | string;
-export declare function toQueryString(obj: {
-    [key: string]: string | undefined;
-}): string;
-export declare function getConnectionUrl(config: EWapiConnectionOptions): string;
-export declare function getConnectionParams(config: EWapiConnectionOptions): [string, {
-    rejectUnauthorized: boolean;
-}?];
-export declare function modifyObject<R>(orig: unknown, modifications: {
-    [k: string]: string | ((i: any) => any);
-}): R;
-export declare function orderByToOrder(orderBy: string): ITxOrderingInput[];
-export declare function mergeFnOptions<Input extends {
-    options?: Options;
-}, Options extends object>(input?: Input & {
-    options?: Options;
-}, options?: Options): {
-    filter: Omit<Input, 'options'>;
-    options: Options;
-};
-export declare function mergeFnOptionsOrderBy<T extends {
-    order_by?: string | undefined;
-    order?: ITxOrderingInput[];
-}>(options: T): Omit<T, 'order_by'>;
-export declare function convertToString(input?: unknown): string | undefined;
-export declare function convertToNumber(input: string | number): number;
-export declare function isFutureDate(dateString: string): boolean;
-export declare function isDate(str: string): boolean;
-export declare function isDateTime(str: string): boolean;
-export {};

package/dist/lib/validation.d.ts

@@ -1,50 +0,0 @@
-import { z } from './zod';
-import { ValidationError } from './errors';
-export interface LogFn {
-    (obj: unknown, msg?: string, ...args: unknown[]): void;
-    (msg: string, ...args: unknown[]): void;
-}
-export interface Logger {
-    warn: LogFn;
-}
-export type WithRequiredOptions<T> = {
-    [P in keyof T as Exclude<P, 'options'>]: T[P];
-} & {
-    [P in keyof T as P extends 'options' ? P : never]-?: T[P];
-};
-export type SoftValidationOutput<T extends z.ZodTypeAny> = {
-    data: z.infer<T>;
-    success: boolean;
-    isValid: boolean;
-    error?: undefined;
-} | {
-    data?: z.infer<T>;
-    success: boolean;
-    isValid: boolean;
-    error: ValidationError;
-};
-export type SoftValidationOutputWOptions<T extends z.ZodTypeAny> = {
-    data: WithRequiredOptions<z.infer<T>>;
-    success: boolean;
-    isValid: boolean;
-    error?: undefined;
-} | {
-    data?: WithRequiredOptions<z.infer<T>>;
-    success: boolean;
-    isValid: boolean;
-    error: ValidationError;
-};
-export declare const getValidatorError: (error: z.ZodError | undefined, _input: unknown) => ValidationError | undefined;
-type ErrorFormatter = typeof getValidatorError;
-export declare const softValidate: <T extends z.ZodTypeAny>(schema: T, input: unknown, formatError?: ErrorFormatter) => SoftValidationOutput<T>;
-export declare const softValidateWOptions: <T extends z.ZodTypeAny>(schema: T, input: unknown, options?: unknown, formatError?: ErrorFormatter) => SoftValidationOutputWOptions<T>;
-export declare const hardValidate: <T extends z.ZodTypeAny>(schema: T, input: unknown, log?: Logger, formatError?: ErrorFormatter) => z.infer<T>;
-export declare const hardValidateWOptions: <T extends z.ZodTypeAny>(schema: T, input: unknown, options?: unknown | Logger, log?: Logger, formatError?: ErrorFormatter) => WithRequiredOptions<z.infer<T>>;
-export type ZodValidator<T extends z.ZodTypeAny> = {
-    validateInput: (input: unknown, log?: Logger) => z.infer<T>;
-    validateInputWOptions: (input: unknown, options?: unknown, log?: Logger) => WithRequiredOptions<z.infer<T>>;
-    softValidateInput: (input: unknown) => SoftValidationOutput<T>;
-    softValidateWOptions: (input: unknown, options?: unknown) => SoftValidationOutputWOptions<T>;
-};
-export declare const getValidator: <T extends z.ZodTypeAny>(schema: T, formatError?: ErrorFormatter) => ZodValidator<T>;
-export {};

package/dist/lib/validator.d.ts

@@ -1,286 +0,0 @@
-import { ZodValidator } from './validation';
-import { aggregateTransfersFnInputSchema, aggregateTransfersFnOutputSchema } from '../fns/aggregate-transfers/aggregate-transfers.schema.zod';
-import { createAccessTokenFnInputSchema, createAccessTokenFnOutputSchema } from '../fns/create-access-token/create-access-token.schema.zod';
-import { createContractFnInputSchema, createContractFnOutputSchema } from '../fns/create-contract/create-contract.schema.zod';
-import { createDepositFnInputSchema, createDepositFnOutputSchema } from '../fns/create-deposit/create-deposit.schema.zod';
-import { createExchangeFnInputSchema, createExchangeFnOutputSchema } from '../fns/create-exchange/create-exchange.schema.zod';
-import { createTokenFnInputSchema, createTokenFnOutputSchema } from '../fns/create-token/create-token.schema.zod';
-import { createTransferFnInputSchema, createTransferFnOutputSchema } from '../fns/create-transfer/create-transfer.schema.zod';
-import { createTransferGroupFnInputSchema, createTransferGroupFnOutputSchema } from '../fns/create-transfer-group/create-transfer-group.schema.zod';
-import { createTransfersFnInputSchema, createTransfersFnOutputSchema } from '../fns/create-transfers/create-transfers.schema.zod';
-import { createWalletFnInputSchema, createWalletFnOutputSchema } from '../fns/create-wallet/create-wallet.schema.zod';
-import { createWithdrawalFnInputSchema, createWithdrawalFnOutputSchema } from '../fns/create-withdrawal/create-withdrawal.schema.zod';
-import { exportBalanceHistoryFnInputSchema, exportBalanceHistoryFnOutputSchema } from '../fns/export-balance-history/export-balance-history.schema.zod';
-import { exportTokensFnInputSchema, exportTokensFnOutputSchema } from '../fns/export-tokens/export-tokens.schema.zod';
-import { exportTransferGroupsFnInputSchema, exportTransferGroupsFnOutputSchema } from '../fns/export-transfer-groups/export-transfer-groups.schema.zod';
-import { exportTransfersFnInputSchema, exportTransfersFnOutputSchema } from '../fns/export-transfers/export-transfers.schema.zod';
-import { exportWalletsFnInputSchema, exportWalletsFnOutputSchema } from '../fns/export-wallets/export-wallets.schema.zod';
-import { findBalancesFnInputSchema, findBalancesFnOutputSchema } from '../fns/find-balances/find-balances.schema.zod';
-import { findTokensFnInputSchema, findTokensFnOutputSchema } from '../fns/find-tokens/find-tokens.schema.zod';
-import { findTransferGroupsFnInputSchema, findTransferGroupsFnOutputSchema } from '../fns/find-transfer-groups/find-transfer-groups.schema.zod';
-import { findTransfersFnInputSchema, findTransfersFnOutputSchema } from '../fns/find-transfers/find-transfers.schema.zod';
-import { findWalletsFnInputSchema, findWalletsFnOutputSchema } from '../fns/find-wallets/find-wallets.schema.zod';
-import { getBalanceFnInputSchema, getBalanceFnOutputSchema } from '../fns/get-balance/get-balance.schema.zod';
-import { getBalanceHistoryFnInputSchema, getBalanceHistoryFnOutputSchema } from '../fns/get-balance-history/get-balance-history.schema.zod';
-import { getExportFnInputSchema, getExportFnOutputSchema } from '../fns/get-export/get-export.schema.zod';
-import { getFlagsFnInputSchema, getFlagsFnOutputSchema } from '../fns/get-flags/get-flags.schema.zod';
-import { getStatisticsFnInputSchema, getStatisticsFnOutputSchema } from '../fns/get-statistics/get-statistics.schema.zod';
-import { getTokenFnInputSchema, getTokenFnOutputSchema } from '../fns/get-token/get-token.schema.zod';
-import { getTransferFnInputSchema, getTransferFnOutputSchema } from '../fns/get-transfer/get-transfer.schema.zod';
-import { getTransferGroupFnInputSchema, getTransferGroupFnOutputSchema } from '../fns/get-transfer-group/get-transfer-group.schema.zod';
-import { getWalletFnInputSchema, getWalletFnOutputSchema } from '../fns/get-wallet/get-wallet.schema.zod';
-import { healthcheckFnInputSchema, healthcheckFnOutputSchema } from '../fns/healthcheck/healthcheck.schema.zod';
-import { listExportsFnInputSchema, listExportsFnOutputSchema } from '../fns/list-exports/list-exports.schema.zod';
-import { reverseTransferFnInputSchema, reverseTransferFnOutputSchema } from '../fns/reverse-transfer/reverse-transfer.schema.zod';
-import { reverseTransferGroupFnInputSchema, reverseTransferGroupFnOutputSchema } from '../fns/reverse-transfer-group/reverse-transfer-group.schema.zod';
-import { reverseTransfersFnInputSchema, reverseTransfersFnOutputSchema } from '../fns/reverse-transfers/reverse-transfers.schema.zod';
-import { setFlagsFnInputSchema, setFlagsFnOutputSchema } from '../fns/set-flags/set-flags.schema.zod';
-import { updateTokenFnInputSchema, updateTokenFnOutputSchema } from '../fns/update-token/update-token.schema.zod';
-import { updateTransferFnInputSchema, updateTransferFnOutputSchema } from '../fns/update-transfer/update-transfer.schema.zod';
-import { updateTransferGroupFnInputSchema, updateTransferGroupFnOutputSchema } from '../fns/update-transfer-group/update-transfer-group.schema.zod';
-import { updateTransferGroupsFnInputSchema, updateTransferGroupsFnOutputSchema } from '../fns/update-transfer-groups/update-transfer-groups.schema.zod';
-import { updateTransfersFnInputSchema, updateTransfersFnOutputSchema } from '../fns/update-transfers/update-transfers.schema.zod';
-import { updateWalletFnInputSchema, updateWalletFnOutputSchema } from '../fns/update-wallet/update-wallet.schema.zod';
-import { aggregateTransferManyTxInputSchema, aggregateTransferManyTxOutputSchema } from '../txs/aggregate-transfer-many/aggregate-transfer-many.schema.zod';
-import { authenticationCheckTxInputSchema, authenticationCheckTxOutputSchema } from '../txs/authentication-check/authentication-check.schema.zod';
-import { createAccessTokenTxInputSchema, createAccessTokenTxOutputSchema } from '../txs/create-access-token/create-access-token.schema.zod';
-import { createContractTxInputSchema, createContractTxOutputSchema } from '../txs/create-contract/create-contract.schema.zod';
-import { createDepositTxInputSchema, createDepositTxOutputSchema } from '../txs/create-deposit/create-deposit.schema.zod';
-import { createDistributionTxInputSchema, createDistributionTxOutputSchema } from '../txs/create-distribution/create-distribution.schema.zod';
-import { createTokenTxInputSchema, createTokenTxOutputSchema } from '../txs/create-token/create-token.schema.zod';
-import { createTransferTxInputSchema, createTransferTxOutputSchema } from '../txs/create-transfer/create-transfer.schema.zod';
-import { createTransferGroupTxInputSchema, createTransferGroupTxOutputSchema } from '../txs/create-transfer-group/create-transfer-group.schema.zod';
-import { createTransferManyTxInputSchema, createTransferManyTxOutputSchema } from '../txs/create-transfer-many/create-transfer-many.schema.zod';
-import { createWalletTxInputSchema, createWalletTxOutputSchema } from '../txs/create-wallet/create-wallet.schema.zod';
-import { createWithdrawalTxInputSchema, createWithdrawalTxOutputSchema } from '../txs/create-withdrawal/create-withdrawal.schema.zod';
-import { exportBalanceHistoryTxInputSchema, exportBalanceHistoryTxOutputSchema } from '../txs/export-balance-history/export-balance-history.schema.zod';
-import { exportTokenManyTxInputSchema, exportTokenManyTxOutputSchema } from '../txs/export-token-many/export-token-many.schema.zod';
-import { exportTransferGroupManyTxInputSchema, exportTransferGroupManyTxOutputSchema } from '../txs/export-transfer-group-many/export-transfer-group-many.schema.zod';
-import { exportTransferManyTxInputSchema, exportTransferManyTxOutputSchema } from '../txs/export-transfer-many/export-transfer-many.schema.zod';
-import { exportWalletManyTxInputSchema, exportWalletManyTxOutputSchema } from '../txs/export-wallet-many/export-wallet-many.schema.zod';
-import { findBalanceManyTxInputSchema, findBalanceManyTxOutputSchema } from '../txs/find-balance-many/find-balance-many.schema.zod';
-import { findTokenManyTxInputSchema, findTokenManyTxOutputSchema } from '../txs/find-token-many/find-token-many.schema.zod';
-import { findTransferGroupManyTxInputSchema, findTransferGroupManyTxOutputSchema } from '../txs/find-transfer-group-many/find-transfer-group-many.schema.zod';
-import { findTransferManyTxInputSchema, findTransferManyTxOutputSchema } from '../txs/find-transfer-many/find-transfer-many.schema.zod';
-import { findWalletManyTxInputSchema, findWalletManyTxOutputSchema } from '../txs/find-wallet-many/find-wallet-many.schema.zod';
-import { finishTransactionTxInputSchema, finishTransactionTxOutputSchema } from '../txs/finish-transaction/finish-transaction.schema.zod';
-import { getBalanceTxInputSchema, getBalanceTxOutputSchema } from '../txs/get-balance/get-balance.schema.zod';
-import { getBalanceHistoryTxInputSchema, getBalanceHistoryTxOutputSchema } from '../txs/get-balance-history/get-balance-history.schema.zod';
-import { getExportTxInputSchema, getExportTxOutputSchema } from '../txs/get-export/get-export.schema.zod';
-import { getFlagsTxInputSchema, getFlagsTxOutputSchema } from '../txs/get-flags/get-flags.schema.zod';
-import { getStatisticsTxInputSchema, getStatisticsTxOutputSchema } from '../txs/get-statistics/get-statistics.schema.zod';
-import { getTokenTxInputSchema, getTokenTxOutputSchema } from '../txs/get-token/get-token.schema.zod';
-import { getTokenManyTxInputSchema, getTokenManyTxOutputSchema } from '../txs/get-token-many/get-token-many.schema.zod';
-import { getTransferTxInputSchema, getTransferTxOutputSchema } from '../txs/get-transfer/get-transfer.schema.zod';
-import { getTransferGroupTxInputSchema, getTransferGroupTxOutputSchema } from '../txs/get-transfer-group/get-transfer-group.schema.zod';
-import { getWalletTxInputSchema, getWalletTxOutputSchema } from '../txs/get-wallet/get-wallet.schema.zod';
-import { getWalletManyTxInputSchema, getWalletManyTxOutputSchema } from '../txs/get-wallet-many/get-wallet-many.schema.zod';
-import { healthcheckTxInputSchema, healthcheckTxOutputSchema } from '../txs/healthcheck/healthcheck.schema.zod';
-import { importActionsTxInputSchema, importActionsTxOutputSchema } from '../txs/import-actions/import-actions.schema.zod';
-import { listExportManyTxInputSchema, listExportManyTxOutputSchema } from '../txs/list-export-many/list-export-many.schema.zod';
-import { queryLogsTxInputSchema, queryLogsTxOutputSchema } from '../txs/query-logs/query-logs.schema.zod';
-import { resetDatabaseTxInputSchema, resetDatabaseTxOutputSchema } from '../txs/reset-database/reset-database.schema.zod';
-import { reverseTransferTxInputSchema, reverseTransferTxOutputSchema } from '../txs/reverse-transfer/reverse-transfer.schema.zod';
-import { reverseTransferGroupTxInputSchema, reverseTransferGroupTxOutputSchema } from '../txs/reverse-transfer-group/reverse-transfer-group.schema.zod';
-import { reverseTransferGroupManyTxInputSchema, reverseTransferGroupManyTxOutputSchema } from '../txs/reverse-transfer-group-many/reverse-transfer-group-many.schema.zod';
-import { reverseTransferManyTxInputSchema, reverseTransferManyTxOutputSchema } from '../txs/reverse-transfer-many/reverse-transfer-many.schema.zod';
-import { setFlagsTxInputSchema, setFlagsTxOutputSchema } from '../txs/set-flags/set-flags.schema.zod';
-import { startTransactionTxInputSchema, startTransactionTxOutputSchema } from '../txs/start-transaction/start-transaction.schema.zod';
-import { updateTokenTxInputSchema, updateTokenTxOutputSchema } from '../txs/update-token/update-token.schema.zod';
-import { updateTransferTxInputSchema, updateTransferTxOutputSchema } from '../txs/update-transfer/update-transfer.schema.zod';
-import { updateTransferGroupTxInputSchema, updateTransferGroupTxOutputSchema } from '../txs/update-transfer-group/update-transfer-group.schema.zod';
-import { updateTransferGroupManyTxInputSchema, updateTransferGroupManyTxOutputSchema } from '../txs/update-transfer-group-many/update-transfer-group-many.schema.zod';
-import { updateTransferManyTxInputSchema, updateTransferManyTxOutputSchema } from '../txs/update-transfer-many/update-transfer-many.schema.zod';
-import { updateWalletTxInputSchema, updateWalletTxOutputSchema } from '../txs/update-wallet/update-wallet.schema.zod';
-export type ValidatorObject = {
-    aggregateTransfersFnInput: ZodValidator<typeof aggregateTransfersFnInputSchema>;
-    aggregateTransfersFnOutput: ZodValidator<typeof aggregateTransfersFnOutputSchema>;
-    createAccessTokenFnInput: ZodValidator<typeof createAccessTokenFnInputSchema>;
-    createAccessTokenFnOutput: ZodValidator<typeof createAccessTokenFnOutputSchema>;
-    createContractFnInput: ZodValidator<typeof createContractFnInputSchema>;
-    createContractFnOutput: ZodValidator<typeof createContractFnOutputSchema>;
-    createDepositFnInput: ZodValidator<typeof createDepositFnInputSchema>;
-    createDepositFnOutput: ZodValidator<typeof createDepositFnOutputSchema>;
-    createExchangeFnInput: ZodValidator<typeof createExchangeFnInputSchema>;
-    createExchangeFnOutput: ZodValidator<typeof createExchangeFnOutputSchema>;
-    createTokenFnInput: ZodValidator<typeof createTokenFnInputSchema>;
-    createTokenFnOutput: ZodValidator<typeof createTokenFnOutputSchema>;
-    createTransferFnInput: ZodValidator<typeof createTransferFnInputSchema>;
-    createTransferFnOutput: ZodValidator<typeof createTransferFnOutputSchema>;
-    createTransferGroupFnInput: ZodValidator<typeof createTransferGroupFnInputSchema>;
-    createTransferGroupFnOutput: ZodValidator<typeof createTransferGroupFnOutputSchema>;
-    createTransfersFnInput: ZodValidator<typeof createTransfersFnInputSchema>;
-    createTransfersFnOutput: ZodValidator<typeof createTransfersFnOutputSchema>;
-    createWalletFnInput: ZodValidator<typeof createWalletFnInputSchema>;
-    createWalletFnOutput: ZodValidator<typeof createWalletFnOutputSchema>;
-    createWithdrawalFnInput: ZodValidator<typeof createWithdrawalFnInputSchema>;
-    createWithdrawalFnOutput: ZodValidator<typeof createWithdrawalFnOutputSchema>;
-    exportBalanceHistoryFnInput: ZodValidator<typeof exportBalanceHistoryFnInputSchema>;
-    exportBalanceHistoryFnOutput: ZodValidator<typeof exportBalanceHistoryFnOutputSchema>;
-    exportTokensFnInput: ZodValidator<typeof exportTokensFnInputSchema>;
-    exportTokensFnOutput: ZodValidator<typeof exportTokensFnOutputSchema>;
-    exportTransferGroupsFnInput: ZodValidator<typeof exportTransferGroupsFnInputSchema>;
-    exportTransferGroupsFnOutput: ZodValidator<typeof exportTransferGroupsFnOutputSchema>;
-    exportTransfersFnInput: ZodValidator<typeof exportTransfersFnInputSchema>;
-    exportTransfersFnOutput: ZodValidator<typeof exportTransfersFnOutputSchema>;
-    exportWalletsFnInput: ZodValidator<typeof exportWalletsFnInputSchema>;
-    exportWalletsFnOutput: ZodValidator<typeof exportWalletsFnOutputSchema>;
-    findBalancesFnInput: ZodValidator<typeof findBalancesFnInputSchema>;
-    findBalancesFnOutput: ZodValidator<typeof findBalancesFnOutputSchema>;
-    findTokensFnInput: ZodValidator<typeof findTokensFnInputSchema>;
-    findTokensFnOutput: ZodValidator<typeof findTokensFnOutputSchema>;
-    findTransferGroupsFnInput: ZodValidator<typeof findTransferGroupsFnInputSchema>;
-    findTransferGroupsFnOutput: ZodValidator<typeof findTransferGroupsFnOutputSchema>;
-    findTransfersFnInput: ZodValidator<typeof findTransfersFnInputSchema>;
-    findTransfersFnOutput: ZodValidator<typeof findTransfersFnOutputSchema>;
-    findWalletsFnInput: ZodValidator<typeof findWalletsFnInputSchema>;
-    findWalletsFnOutput: ZodValidator<typeof findWalletsFnOutputSchema>;
-    getBalanceFnInput: ZodValidator<typeof getBalanceFnInputSchema>;
-    getBalanceFnOutput: ZodValidator<typeof getBalanceFnOutputSchema>;
-    getBalanceHistoryFnInput: ZodValidator<typeof getBalanceHistoryFnInputSchema>;
-    getBalanceHistoryFnOutput: ZodValidator<typeof getBalanceHistoryFnOutputSchema>;
-    getExportFnInput: ZodValidator<typeof getExportFnInputSchema>;
-    getExportFnOutput: ZodValidator<typeof getExportFnOutputSchema>;
-    getFlagsFnInput: ZodValidator<typeof getFlagsFnInputSchema>;
-    getFlagsFnOutput: ZodValidator<typeof getFlagsFnOutputSchema>;
-    getStatisticsFnInput: ZodValidator<typeof getStatisticsFnInputSchema>;
-    getStatisticsFnOutput: ZodValidator<typeof getStatisticsFnOutputSchema>;
-    getTokenFnInput: ZodValidator<typeof getTokenFnInputSchema>;
-    getTokenFnOutput: ZodValidator<typeof getTokenFnOutputSchema>;
-    getTransferFnInput: ZodValidator<typeof getTransferFnInputSchema>;
-    getTransferFnOutput: ZodValidator<typeof getTransferFnOutputSchema>;
-    getTransferGroupFnInput: ZodValidator<typeof getTransferGroupFnInputSchema>;
-    getTransferGroupFnOutput: ZodValidator<typeof getTransferGroupFnOutputSchema>;
-    getWalletFnInput: ZodValidator<typeof getWalletFnInputSchema>;
-    getWalletFnOutput: ZodValidator<typeof getWalletFnOutputSchema>;
-    healthcheckFnInput: ZodValidator<typeof healthcheckFnInputSchema>;
-    healthcheckFnOutput: ZodValidator<typeof healthcheckFnOutputSchema>;
-    listExportsFnInput: ZodValidator<typeof listExportsFnInputSchema>;
-    listExportsFnOutput: ZodValidator<typeof listExportsFnOutputSchema>;
-    reverseTransferFnInput: ZodValidator<typeof reverseTransferFnInputSchema>;
-    reverseTransferFnOutput: ZodValidator<typeof reverseTransferFnOutputSchema>;
-    reverseTransferGroupFnInput: ZodValidator<typeof reverseTransferGroupFnInputSchema>;
-    reverseTransferGroupFnOutput: ZodValidator<typeof reverseTransferGroupFnOutputSchema>;
-    reverseTransfersFnInput: ZodValidator<typeof reverseTransfersFnInputSchema>;
-    reverseTransfersFnOutput: ZodValidator<typeof reverseTransfersFnOutputSchema>;
-    setFlagsFnInput: ZodValidator<typeof setFlagsFnInputSchema>;
-    setFlagsFnOutput: ZodValidator<typeof setFlagsFnOutputSchema>;
-    updateTokenFnInput: ZodValidator<typeof updateTokenFnInputSchema>;
-    updateTokenFnOutput: ZodValidator<typeof updateTokenFnOutputSchema>;
-    updateTransferFnInput: ZodValidator<typeof updateTransferFnInputSchema>;
-    updateTransferFnOutput: ZodValidator<typeof updateTransferFnOutputSchema>;
-    updateTransferGroupFnInput: ZodValidator<typeof updateTransferGroupFnInputSchema>;
-    updateTransferGroupFnOutput: ZodValidator<typeof updateTransferGroupFnOutputSchema>;
-    updateTransferGroupsFnInput: ZodValidator<typeof updateTransferGroupsFnInputSchema>;
-    updateTransferGroupsFnOutput: ZodValidator<typeof updateTransferGroupsFnOutputSchema>;
-    updateTransfersFnInput: ZodValidator<typeof updateTransfersFnInputSchema>;
-    updateTransfersFnOutput: ZodValidator<typeof updateTransfersFnOutputSchema>;
-    updateWalletFnInput: ZodValidator<typeof updateWalletFnInputSchema>;
-    updateWalletFnOutput: ZodValidator<typeof updateWalletFnOutputSchema>;
-    aggregateTransferManyTxInput: ZodValidator<typeof aggregateTransferManyTxInputSchema>;
-    aggregateTransferManyTxOutput: ZodValidator<typeof aggregateTransferManyTxOutputSchema>;
-    authenticationCheckTxInput: ZodValidator<typeof authenticationCheckTxInputSchema>;
-    authenticationCheckTxOutput: ZodValidator<typeof authenticationCheckTxOutputSchema>;
-    createAccessTokenTxInput: ZodValidator<typeof createAccessTokenTxInputSchema>;
-    createAccessTokenTxOutput: ZodValidator<typeof createAccessTokenTxOutputSchema>;
-    createContractTxInput: ZodValidator<typeof createContractTxInputSchema>;
-    createContractTxOutput: ZodValidator<typeof createContractTxOutputSchema>;
-    createDepositTxInput: ZodValidator<typeof createDepositTxInputSchema>;
-    createDepositTxOutput: ZodValidator<typeof createDepositTxOutputSchema>;
-    createDistributionTxInput: ZodValidator<typeof createDistributionTxInputSchema>;
-    createDistributionTxOutput: ZodValidator<typeof createDistributionTxOutputSchema>;
-    createTokenTxInput: ZodValidator<typeof createTokenTxInputSchema>;
-    createTokenTxOutput: ZodValidator<typeof createTokenTxOutputSchema>;
-    createTransferTxInput: ZodValidator<typeof createTransferTxInputSchema>;
-    createTransferTxOutput: ZodValidator<typeof createTransferTxOutputSchema>;
-    createTransferGroupTxInput: ZodValidator<typeof createTransferGroupTxInputSchema>;
-    createTransferGroupTxOutput: ZodValidator<typeof createTransferGroupTxOutputSchema>;
-    createTransferManyTxInput: ZodValidator<typeof createTransferManyTxInputSchema>;
-    createTransferManyTxOutput: ZodValidator<typeof createTransferManyTxOutputSchema>;
-    createWalletTxInput: ZodValidator<typeof createWalletTxInputSchema>;
-    createWalletTxOutput: ZodValidator<typeof createWalletTxOutputSchema>;
-    createWithdrawalTxInput: ZodValidator<typeof createWithdrawalTxInputSchema>;
-    createWithdrawalTxOutput: ZodValidator<typeof createWithdrawalTxOutputSchema>;
-    exportBalanceHistoryTxInput: ZodValidator<typeof exportBalanceHistoryTxInputSchema>;
-    exportBalanceHistoryTxOutput: ZodValidator<typeof exportBalanceHistoryTxOutputSchema>;
-    exportTokenManyTxInput: ZodValidator<typeof exportTokenManyTxInputSchema>;
-    exportTokenManyTxOutput: ZodValidator<typeof exportTokenManyTxOutputSchema>;
-    exportTransferGroupManyTxInput: ZodValidator<typeof exportTransferGroupManyTxInputSchema>;
-    exportTransferGroupManyTxOutput: ZodValidator<typeof exportTransferGroupManyTxOutputSchema>;
-    exportTransferManyTxInput: ZodValidator<typeof exportTransferManyTxInputSchema>;
-    exportTransferManyTxOutput: ZodValidator<typeof exportTransferManyTxOutputSchema>;
-    exportWalletManyTxInput: ZodValidator<typeof exportWalletManyTxInputSchema>;
-    exportWalletManyTxOutput: ZodValidator<typeof exportWalletManyTxOutputSchema>;
-    findBalanceManyTxInput: ZodValidator<typeof findBalanceManyTxInputSchema>;
-    findBalanceManyTxOutput: ZodValidator<typeof findBalanceManyTxOutputSchema>;
-    findTokenManyTxInput: ZodValidator<typeof findTokenManyTxInputSchema>;
-    findTokenManyTxOutput: ZodValidator<typeof findTokenManyTxOutputSchema>;
-    findTransferGroupManyTxInput: ZodValidator<typeof findTransferGroupManyTxInputSchema>;
-    findTransferGroupManyTxOutput: ZodValidator<typeof findTransferGroupManyTxOutputSchema>;
-    findTransferManyTxInput: ZodValidator<typeof findTransferManyTxInputSchema>;
-    findTransferManyTxOutput: ZodValidator<typeof findTransferManyTxOutputSchema>;
-    findWalletManyTxInput: ZodValidator<typeof findWalletManyTxInputSchema>;
-    findWalletManyTxOutput: ZodValidator<typeof findWalletManyTxOutputSchema>;
-    finishTransactionTxInput: ZodValidator<typeof finishTransactionTxInputSchema>;
-    finishTransactionTxOutput: ZodValidator<typeof finishTransactionTxOutputSchema>;
-    getBalanceTxInput: ZodValidator<typeof getBalanceTxInputSchema>;
-    getBalanceTxOutput: ZodValidator<typeof getBalanceTxOutputSchema>;
-    getBalanceHistoryTxInput: ZodValidator<typeof getBalanceHistoryTxInputSchema>;
-    getBalanceHistoryTxOutput: ZodValidator<typeof getBalanceHistoryTxOutputSchema>;
-    getExportTxInput: ZodValidator<typeof getExportTxInputSchema>;
-    getExportTxOutput: ZodValidator<typeof getExportTxOutputSchema>;
-    getFlagsTxInput: ZodValidator<typeof getFlagsTxInputSchema>;
-    getFlagsTxOutput: ZodValidator<typeof getFlagsTxOutputSchema>;
-    getStatisticsTxInput: ZodValidator<typeof getStatisticsTxInputSchema>;
-    getStatisticsTxOutput: ZodValidator<typeof getStatisticsTxOutputSchema>;
-    getTokenTxInput: ZodValidator<typeof getTokenTxInputSchema>;
-    getTokenTxOutput: ZodValidator<typeof getTokenTxOutputSchema>;
-    getTokenManyTxInput: ZodValidator<typeof getTokenManyTxInputSchema>;
-    getTokenManyTxOutput: ZodValidator<typeof getTokenManyTxOutputSchema>;
-    getTransferTxInput: ZodValidator<typeof getTransferTxInputSchema>;
-    getTransferTxOutput: ZodValidator<typeof getTransferTxOutputSchema>;
-    getTransferGroupTxInput: ZodValidator<typeof getTransferGroupTxInputSchema>;
-    getTransferGroupTxOutput: ZodValidator<typeof getTransferGroupTxOutputSchema>;
-    getWalletTxInput: ZodValidator<typeof getWalletTxInputSchema>;
-    getWalletTxOutput: ZodValidator<typeof getWalletTxOutputSchema>;
-    getWalletManyTxInput: ZodValidator<typeof getWalletManyTxInputSchema>;
-    getWalletManyTxOutput: ZodValidator<typeof getWalletManyTxOutputSchema>;
-    healthcheckTxInput: ZodValidator<typeof healthcheckTxInputSchema>;
-    healthcheckTxOutput: ZodValidator<typeof healthcheckTxOutputSchema>;
-    importActionsTxInput: ZodValidator<typeof importActionsTxInputSchema>;
-    importActionsTxOutput: ZodValidator<typeof importActionsTxOutputSchema>;
-    listExportManyTxInput: ZodValidator<typeof listExportManyTxInputSchema>;
-    listExportManyTxOutput: ZodValidator<typeof listExportManyTxOutputSchema>;
-    queryLogsTxInput: ZodValidator<typeof queryLogsTxInputSchema>;
-    queryLogsTxOutput: ZodValidator<typeof queryLogsTxOutputSchema>;
-    resetDatabaseTxInput: ZodValidator<typeof resetDatabaseTxInputSchema>;
-    resetDatabaseTxOutput: ZodValidator<typeof resetDatabaseTxOutputSchema>;
-    reverseTransferTxInput: ZodValidator<typeof reverseTransferTxInputSchema>;
-    reverseTransferTxOutput: ZodValidator<typeof reverseTransferTxOutputSchema>;
-    reverseTransferGroupTxInput: ZodValidator<typeof reverseTransferGroupTxInputSchema>;
-    reverseTransferGroupTxOutput: ZodValidator<typeof reverseTransferGroupTxOutputSchema>;
-    reverseTransferGroupManyTxInput: ZodValidator<typeof reverseTransferGroupManyTxInputSchema>;
-    reverseTransferGroupManyTxOutput: ZodValidator<typeof reverseTransferGroupManyTxOutputSchema>;
-    reverseTransferManyTxInput: ZodValidator<typeof reverseTransferManyTxInputSchema>;
-    reverseTransferManyTxOutput: ZodValidator<typeof reverseTransferManyTxOutputSchema>;
-    setFlagsTxInput: ZodValidator<typeof setFlagsTxInputSchema>;
-    setFlagsTxOutput: ZodValidator<typeof setFlagsTxOutputSchema>;
-    startTransactionTxInput: ZodValidator<typeof startTransactionTxInputSchema>;
-    startTransactionTxOutput: ZodValidator<typeof startTransactionTxOutputSchema>;
-    updateTokenTxInput: ZodValidator<typeof updateTokenTxInputSchema>;
-    updateTokenTxOutput: ZodValidator<typeof updateTokenTxOutputSchema>;
-    updateTransferTxInput: ZodValidator<typeof updateTransferTxInputSchema>;
-    updateTransferTxOutput: ZodValidator<typeof updateTransferTxOutputSchema>;
-    updateTransferGroupTxInput: ZodValidator<typeof updateTransferGroupTxInputSchema>;
-    updateTransferGroupTxOutput: ZodValidator<typeof updateTransferGroupTxOutputSchema>;
-    updateTransferGroupManyTxInput: ZodValidator<typeof updateTransferGroupManyTxInputSchema>;
-    updateTransferGroupManyTxOutput: ZodValidator<typeof updateTransferGroupManyTxOutputSchema>;
-    updateTransferManyTxInput: ZodValidator<typeof updateTransferManyTxInputSchema>;
-    updateTransferManyTxOutput: ZodValidator<typeof updateTransferManyTxOutputSchema>;
-    updateWalletTxInput: ZodValidator<typeof updateWalletTxInputSchema>;
-    updateWalletTxOutput: ZodValidator<typeof updateWalletTxOutputSchema>;
-};
-/**
- * Validator object to allow JSON Schema validation to be run by user
- */
-export declare const Validator: ValidatorObject;

package/dist/lib/ws-types.d.ts

@@ -1,18 +0,0 @@
-import WebSocket from 'modern-isomorphic-ws';
-export interface ErrorEvent {
-    error: unknown;
-    message: string;
-    type: string;
-    target: WebSocket;
-}
-export interface CloseEvent {
-    wasClean: boolean;
-    code: number;
-    reason: string;
-    target: WebSocket;
-}
-export interface MessageEvent {
-    data: unknown;
-    type: string;
-    target: WebSocket;
-}

package/dist/lib/zod.d.ts

@@ -1,2 +0,0 @@
-export { z } from 'zod';
-export type { RefinementCtx } from 'zod';

package/dist/txs/aggregate-transfer-many/aggregate-transfer-many.enums.d.ts

@@ -1,14 +0,0 @@
-/**
- * This file is generated on build
- */
-import { z } from '../../lib/zod';
-import { aggregateTransferManyAggregator, aggregateTransferManyAggregatorComplex, aggregateTransferManyAggregatorFields, aggregateTransferManyGroupFieldSchema, aggregateTransferManyGroupSchema, aggregateTransferManyTxInputAdditionalOptions, aggregateTransferManyTxInputOptionsSchema, aggregateTransferManyTxInputSchema, aggregateTransferManyTxOutputSchema } from './aggregate-transfer-many.schema.zod';
-export type AggregateTransferManyAggregator = z.infer<typeof aggregateTransferManyAggregator>;
-export type AggregateTransferManyAggregatorComplex = z.infer<typeof aggregateTransferManyAggregatorComplex>;
-export type AggregateTransferManyAggregatorFields = z.infer<typeof aggregateTransferManyAggregatorFields>;
-export type AggregateTransferManyGroupField = z.infer<typeof aggregateTransferManyGroupFieldSchema>;
-export type AggregateTransferManyGroup = z.infer<typeof aggregateTransferManyGroupSchema>;
-export type AggregateTransferManyTxInputAdditionalOptions = z.infer<typeof aggregateTransferManyTxInputAdditionalOptions>;
-export type AggregateTransferManyTxInputOptions = z.infer<typeof aggregateTransferManyTxInputOptionsSchema>;
-export type AggregateTransferManyTxInput = z.infer<typeof aggregateTransferManyTxInputSchema>;
-export type AggregateTransferManyTxOutput = z.infer<typeof aggregateTransferManyTxOutputSchema>;