nano-sdk 1.0.0

package/dist/nano/rpc/requests/work-generate.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare function WorkGenerateRequest(): z.ZodUnion<readonly [z.ZodObject<{
+    action: z.ZodLiteral<"work_generate">;
+    hash: z.ZodString;
+    json_block: z.ZodLiteral<true>;
+    block: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"state">;
+        account: z.ZodString;
+        previous: z.ZodString;
+        representative: z.ZodString;
+        balance: z.ZodString;
+        link: z.ZodUnion<[z.ZodString, z.ZodString]>;
+        link_as_account: z.ZodString;
+        signature: z.ZodString;
+        work: z.ZodString;
+    }, z.core.$strip>>;
+    use_peers: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+    account: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodLiteral<"work_1">>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"work_generate">;
+    hash: z.ZodString;
+    json_block: z.ZodLiteral<false>;
+    block: z.ZodOptional<z.ZodString>;
+    use_peers: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+    account: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodLiteral<"work_1">>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"work_generate">;
+    hash: z.ZodString;
+    json_block: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+    block: z.ZodOptional<z.ZodString>;
+    use_peers: z.ZodOptional<z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>, z.ZodBoolean]>>;
+    account: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodLiteral<"work_1">>;
+}, z.core.$strip>]>;
+export type WorkGenerateRequest = z.infer<ReturnType<typeof WorkGenerateRequest>>;

package/dist/nano/rpc/requests/work-generate.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkGenerateRequest = WorkGenerateRequest;
+const zod_1 = require("zod");
+const state_block_1 = require("../../blocks/state-block");
+const account_1 = require("../../types/account");
+const boolean_1 = require("../../types/boolean");
+const hash_1 = require("../../types/hash");
+function WorkGenerateRequest() {
+    return zod_1.z.union([
+        zod_1.z.object({
+            action: zod_1.z.literal("work_generate"),
+            hash: (0, hash_1.HashString)(),
+            json_block: zod_1.z.literal(true),
+            block: (0, state_block_1.StateBlock)().optional(),
+            use_peers: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+            account: (0, account_1.AccountString)().optional(),
+            version: zod_1.z.literal("work_1").optional(),
+        }),
+        zod_1.z.object({
+            action: zod_1.z.literal("work_generate"),
+            hash: (0, hash_1.HashString)(),
+            json_block: zod_1.z.literal(false),
+            block: zod_1.z.string().optional(),
+            use_peers: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+            account: (0, account_1.AccountString)().optional(),
+            version: zod_1.z.literal("work_1").optional(),
+        }),
+        zod_1.z.object({
+            action: zod_1.z.literal("work_generate"),
+            hash: (0, hash_1.HashString)(),
+            json_block: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+            block: zod_1.z.string().optional(),
+            use_peers: (0, boolean_1.BooleanString)().or(zod_1.z.boolean()).optional(),
+            account: (0, account_1.AccountString)().optional(),
+            version: zod_1.z.literal("work_1").optional(),
+        }),
+    ]);
+}

package/dist/nano/rpc/requests/work-peer-add.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare function WorkPeerAddRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"work_peer_add">;
+    address: z.ZodString;
+    port: z.ZodUnion<[z.ZodString, z.ZodInt]>;
+}, z.core.$strip>;
+export type WorkPeerAddRequest = z.infer<ReturnType<typeof WorkPeerAddRequest>>;

package/dist/nano/rpc/requests/work-peer-add.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkPeerAddRequest = WorkPeerAddRequest;
+const zod_1 = require("zod");
+const endpoint_1 = require("../../types/endpoint");
+const port_1 = require("../../types/port");
+function WorkPeerAddRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("work_peer_add"),
+        address: (0, endpoint_1.EndpointString)(),
+        port: (0, port_1.PortString)().or((0, port_1.Port)()),
+    });
+}

package/dist/nano/rpc/requests/work-peers-clear.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function WorkPeersClearRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"work_peers_clear">;
+}, z.core.$strip>;
+export type WorkPeersClearRequest = z.infer<ReturnType<typeof WorkPeersClearRequest>>;

package/dist/nano/rpc/requests/work-peers-clear.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkPeersClearRequest = WorkPeersClearRequest;
+const zod_1 = require("zod");
+function WorkPeersClearRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("work_peers_clear"),
+    });
+}

package/dist/nano/rpc/requests/work-peers.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function WorkPeersRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"work_peers">;
+}, z.core.$strip>;
+export type WorkPeersRequest = z.infer<ReturnType<typeof WorkPeersRequest>>;

package/dist/nano/rpc/requests/work-peers.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkPeersRequest = WorkPeersRequest;
+const zod_1 = require("zod");
+function WorkPeersRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("work_peers"),
+    });
+}

package/dist/nano/rpc/requests/work-validate.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare function WorkValidateRequest(): z.ZodObject<{
+    action: z.ZodLiteral<"work_validate">;
+    work: z.ZodString;
+    hash: z.ZodString;
+    version: z.ZodOptional<z.ZodLiteral<"work_1">>;
+}, z.core.$strip>;
+export type WorkValidateRequest = z.infer<ReturnType<typeof WorkValidateRequest>>;

package/dist/nano/rpc/requests/work-validate.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkValidateRequest = WorkValidateRequest;
+const zod_1 = require("zod");
+const hash_1 = require("../../types/hash");
+const work_1 = require("../../types/work");
+function WorkValidateRequest() {
+    return zod_1.z.object({
+        action: zod_1.z.literal("work_validate"),
+        work: (0, work_1.WorkString)(),
+        hash: (0, hash_1.HashString)(),
+        version: zod_1.z.literal("work_1").optional(),
+    });
+}

package/dist/nano/rpc/responses/account-balance.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare function AccountBalanceResponse(): z.ZodObject<{
+    balance: z.ZodString;
+    pending: z.ZodString;
+    receivable: z.ZodString;
+}, z.core.$strip>;
+export type AccountBalanceResponse = z.infer<ReturnType<typeof AccountBalanceResponse>>;

package/dist/nano/rpc/responses/account-balance.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountBalanceResponse = AccountBalanceResponse;
+const zod_1 = require("zod");
+const amount_1 = require("../../types/amount");
+function AccountBalanceResponse() {
+    return zod_1.z.object({
+        balance: (0, amount_1.RawAmountString)(),
+        pending: (0, amount_1.RawAmountString)(),
+        receivable: (0, amount_1.RawAmountString)(),
+    });
+}

package/dist/nano/rpc/responses/account-block-count.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function AccountBlockCountResponse(): z.ZodObject<{
+    block_count: z.ZodString;
+}, z.core.$strip>;
+export type AccountBlockCountResponse = z.infer<ReturnType<typeof AccountBlockCountResponse>>;

package/dist/nano/rpc/responses/account-block-count.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountBlockCountResponse = AccountBlockCountResponse;
+const zod_1 = require("zod");
+const uint_1 = require("../../types/uint");
+function AccountBlockCountResponse() {
+    return zod_1.z.object({
+        block_count: (0, uint_1.UIntString)(),
+    });
+}

package/dist/nano/rpc/responses/account-get.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare function AccountGetResponse(): z.ZodObject<{
+    account: z.ZodString;
+}, z.core.$strip>;
+export type AccountGetResponse = z.infer<ReturnType<typeof AccountGetResponse>>;

package/dist/nano/rpc/responses/account-get.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountGetResponse = AccountGetResponse;
+const zod_1 = require("zod");
+const account_1 = require("../../types/account");
+function AccountGetResponse() {
+    return zod_1.z.object({
+        account: (0, account_1.AccountString)(),
+    });
+}

package/dist/nano/rpc/responses/account-history.d.ts

@@ -0,0 +1,229 @@
+import { z } from "zod";
+import { AccountString } from "../../types/account";
+import { BooleanDistribution } from "../../types/boolean-distribution";
+import { HashString } from "../../types/hash";
+import { UppercaseKeys } from "../../types/uppercase-keys";
+type ChangeStateBlockHistory = z.infer<ReturnType<typeof ChangeStateBlockHistory>>;
+declare const ChangeStateBlockHistory: () => z.ZodObject<{
+    local_timestamp: z.ZodString;
+    height: z.ZodString;
+    hash: z.ZodString;
+    confirmed: z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>;
+    work: z.ZodString;
+    signature: z.ZodString;
+    type: z.ZodLiteral<"state">;
+    previous: z.ZodString;
+    representative: z.ZodString;
+    balance: z.ZodString;
+    link: z.ZodUnion<[z.ZodString, z.ZodString]>;
+    subtype: z.ZodLiteral<"change">;
+}, z.core.$strip>;
+type EpochStateBlockHistory = z.infer<ReturnType<typeof EpochStateBlockHistory>>;
+declare const EpochStateBlockHistory: () => z.ZodObject<{
+    local_timestamp: z.ZodString;
+    height: z.ZodString;
+    hash: z.ZodString;
+    confirmed: z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>;
+    work: z.ZodString;
+    signature: z.ZodString;
+    type: z.ZodLiteral<"state">;
+    previous: z.ZodString;
+    representative: z.ZodString;
+    balance: z.ZodString;
+    link: z.ZodUnion<[z.ZodString, z.ZodString]>;
+    subtype: z.ZodLiteral<"epoch">;
+    account: z.ZodString;
+}, z.core.$strip>;
+type ReceiveStateBlockHistory = z.infer<ReturnType<typeof ReceiveStateBlockHistory>>;
+declare const ReceiveStateBlockHistory: () => z.ZodObject<{
+    local_timestamp: z.ZodString;
+    height: z.ZodString;
+    hash: z.ZodString;
+    confirmed: z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>;
+    work: z.ZodString;
+    signature: z.ZodString;
+    type: z.ZodLiteral<"state">;
+    previous: z.ZodString;
+    representative: z.ZodString;
+    balance: z.ZodString;
+    link: z.ZodUnion<[z.ZodString, z.ZodString]>;
+    subtype: z.ZodLiteral<"receive">;
+    account: z.ZodOptional<z.ZodString>;
+    amount: z.ZodString;
+}, z.core.$strip>;
+type SendStateBlockHistory = z.infer<ReturnType<typeof SendStateBlockHistory>>;
+declare const SendStateBlockHistory: () => z.ZodObject<{
+    local_timestamp: z.ZodString;
+    height: z.ZodString;
+    hash: z.ZodString;
+    confirmed: z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>;
+    work: z.ZodString;
+    signature: z.ZodString;
+    type: z.ZodLiteral<"state">;
+    previous: z.ZodString;
+    representative: z.ZodString;
+    balance: z.ZodString;
+    link: z.ZodUnion<[z.ZodString, z.ZodString]>;
+    subtype: z.ZodLiteral<"send">;
+    account: z.ZodString;
+    amount: z.ZodString;
+}, z.core.$strip>;
+type UnknownStateBlockHistory = z.infer<ReturnType<typeof UnknownStateBlockHistory>>;
+declare const UnknownStateBlockHistory: () => z.ZodObject<{
+    local_timestamp: z.ZodString;
+    height: z.ZodString;
+    hash: z.ZodString;
+    confirmed: z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>;
+    work: z.ZodString;
+    signature: z.ZodString;
+    type: z.ZodLiteral<"state">;
+    previous: z.ZodString;
+    representative: z.ZodString;
+    balance: z.ZodString;
+    link: z.ZodUnion<[z.ZodString, z.ZodString]>;
+    subtype: z.ZodLiteral<"unknown">;
+}, z.core.$strip>;
+type LegacyChangeBlockHistory = z.infer<ReturnType<typeof LegacyChangeBlockHistory>>;
+declare const LegacyChangeBlockHistory: () => z.ZodObject<{
+    local_timestamp: z.ZodString;
+    height: z.ZodString;
+    hash: z.ZodString;
+    confirmed: z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>;
+    work: z.ZodString;
+    signature: z.ZodString;
+    type: z.ZodLiteral<"change">;
+    representative: z.ZodString;
+    previous: z.ZodString;
+}, z.core.$strip>;
+type LegacyOpenBlockHistory = z.infer<ReturnType<typeof LegacyOpenBlockHistory>>;
+declare const LegacyOpenBlockHistory: () => z.ZodObject<{
+    local_timestamp: z.ZodString;
+    height: z.ZodString;
+    hash: z.ZodString;
+    confirmed: z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>;
+    work: z.ZodString;
+    signature: z.ZodString;
+    type: z.ZodLiteral<"open">;
+    representative: z.ZodString;
+    source: z.ZodString;
+    opened: z.ZodString;
+    account: z.ZodString;
+    amount: z.ZodString;
+}, z.core.$strip>;
+type LegacyReceiveBlockHistory = z.infer<ReturnType<typeof LegacyReceiveBlockHistory>>;
+declare const LegacyReceiveBlockHistory: () => z.ZodObject<{
+    local_timestamp: z.ZodString;
+    height: z.ZodString;
+    hash: z.ZodString;
+    confirmed: z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>;
+    work: z.ZodString;
+    signature: z.ZodString;
+    type: z.ZodLiteral<"receive">;
+    account: z.ZodString;
+    amount: z.ZodString;
+    source: z.ZodString;
+    previous: z.ZodString;
+}, z.core.$strip>;
+type LegacySendBlockHistory = z.infer<ReturnType<typeof LegacySendBlockHistory>>;
+declare const LegacySendBlockHistory: () => z.ZodObject<{
+    local_timestamp: z.ZodString;
+    height: z.ZodString;
+    hash: z.ZodString;
+    confirmed: z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>;
+    work: z.ZodString;
+    signature: z.ZodString;
+    type: z.ZodLiteral<"send">;
+    account: z.ZodString;
+    amount: z.ZodString;
+    destination: z.ZodString;
+    balance: z.ZodString;
+    previous: z.ZodString;
+}, z.core.$strip>;
+type AccountHistoryEntryRawOptions = {
+    include_linked_account: boolean;
+};
+type AccountHistoryEntryRawZodType<T extends UppercaseKeys<AccountHistoryEntryRawOptions>> = BooleanDistribution<T["INCLUDE_LINKED_ACCOUNT"], z.ZodUnion<[
+    z.ZodObject<ReturnType<typeof ChangeStateBlockHistory>["shape"] & {
+        linked_account: z.ZodUnion<[ReturnType<typeof AccountString>, z.ZodLiteral<"0">]>;
+    }>,
+    z.ZodObject<ReturnType<typeof EpochStateBlockHistory>["shape"] & {
+        linked_account: z.ZodUnion<[ReturnType<typeof AccountString>, z.ZodLiteral<"0">]>;
+    }>,
+    z.ZodObject<ReturnType<typeof ReceiveStateBlockHistory>["shape"] & {
+        linked_account: z.ZodUnion<[ReturnType<typeof AccountString>, z.ZodLiteral<"0">]>;
+    }>,
+    z.ZodObject<ReturnType<typeof SendStateBlockHistory>["shape"] & {
+        linked_account: z.ZodUnion<[ReturnType<typeof AccountString>, z.ZodLiteral<"0">]>;
+    }>,
+    z.ZodObject<ReturnType<typeof UnknownStateBlockHistory>["shape"] & {
+        linked_account: z.ZodUnion<[ReturnType<typeof AccountString>, z.ZodLiteral<"0">]>;
+    }>,
+    z.ZodObject<ReturnType<typeof LegacyChangeBlockHistory>["shape"] & {
+        linked_account: z.ZodUnion<[ReturnType<typeof AccountString>, z.ZodLiteral<"0">]>;
+    }>,
+    z.ZodObject<ReturnType<typeof LegacyOpenBlockHistory>["shape"] & {
+        linked_account: z.ZodUnion<[ReturnType<typeof AccountString>, z.ZodLiteral<"0">]>;
+    }>,
+    z.ZodObject<ReturnType<typeof LegacyReceiveBlockHistory>["shape"] & {
+        linked_account: z.ZodUnion<[ReturnType<typeof AccountString>, z.ZodLiteral<"0">]>;
+    }>,
+    z.ZodObject<ReturnType<typeof LegacySendBlockHistory>["shape"] & {
+        linked_account: z.ZodUnion<[ReturnType<typeof AccountString>, z.ZodLiteral<"0">]>;
+    }>
+]>, z.ZodUnion<[
+    ReturnType<typeof ChangeStateBlockHistory>,
+    ReturnType<typeof EpochStateBlockHistory>,
+    ReturnType<typeof ReceiveStateBlockHistory>,
+    ReturnType<typeof SendStateBlockHistory>,
+    ReturnType<typeof UnknownStateBlockHistory>,
+    ReturnType<typeof LegacyChangeBlockHistory>,
+    ReturnType<typeof LegacyOpenBlockHistory>,
+    ReturnType<typeof LegacyReceiveBlockHistory>,
+    ReturnType<typeof LegacySendBlockHistory>
+]>>;
+export type AccountHistoryEntryRaw<T extends UppercaseKeys<AccountHistoryEntryRawOptions>> = z.infer<AccountHistoryEntryRawZodType<T>>;
+export declare function AccountHistoryEntryRaw<T extends AccountHistoryEntryRawOptions>(options: T): AccountHistoryEntryRawZodType<UppercaseKeys<T>>;
+type AccountHistoryEntryNotRaw = z.infer<ReturnType<typeof AccountHistoryEntryNotRaw>>;
+declare const AccountHistoryEntryNotRaw: () => z.ZodObject<{
+    type: z.ZodUnion<[z.ZodLiteral<"send">, z.ZodLiteral<"receive">]>;
+    account: z.ZodString;
+    amount: z.ZodString;
+    local_timestamp: z.ZodString;
+    height: z.ZodString;
+    hash: z.ZodString;
+    confirmed: z.ZodUnion<readonly [z.ZodLiteral<"true">, z.ZodLiteral<"false">]>;
+}, z.core.$strip>;
+type AccountHistoryEntryOptions = {
+    include_linked_account: boolean;
+    raw: boolean;
+};
+type AccountHistoryEntryZodType<T extends UppercaseKeys<AccountHistoryEntryOptions>> = BooleanDistribution<T["RAW"], AccountHistoryEntryRawZodType<{
+    INCLUDE_LINKED_ACCOUNT: T["INCLUDE_LINKED_ACCOUNT"];
+}>, BooleanDistribution<T["INCLUDE_LINKED_ACCOUNT"], z.ZodObject<ReturnType<typeof AccountHistoryEntryNotRaw>["shape"] & {
+    linked_account: z.ZodUnion<[ReturnType<typeof AccountString>, z.ZodLiteral<"0">]>;
+}>, ReturnType<typeof AccountHistoryEntryNotRaw>>>;
+export type AccountHistoryEntry<T extends UppercaseKeys<AccountHistoryEntryOptions>> = z.infer<AccountHistoryEntryZodType<T>>;
+export declare function AccountHistoryEntry<T extends AccountHistoryEntryOptions>(options: T): AccountHistoryEntryZodType<UppercaseKeys<T>>;
+type AccountHistoryOptions = {
+    include_linked_account: boolean;
+    raw: boolean;
+};
+type AccountHistoryZodType<T extends UppercaseKeys<AccountHistoryOptions>> = z.ZodArray<AccountHistoryEntryZodType<T>>;
+export type AccountHistory<T extends UppercaseKeys<AccountHistoryOptions>> = z.infer<AccountHistoryZodType<T>>;
+type AccountHistoryResponseOptions = {
+    include_linked_account: boolean;
+    raw: boolean;
+    reverse: boolean;
+};
+type AccountHistoryResponseZodType<T extends UppercaseKeys<AccountHistoryResponseOptions>> = BooleanDistribution<T["REVERSE"], z.ZodObject<{
+    account: ReturnType<typeof AccountString>;
+    history: z.ZodUnion<[AccountHistoryZodType<T>, z.ZodLiteral<"">]>;
+    next: z.ZodOptional<ReturnType<typeof HashString>>;
+}>, z.ZodObject<{
+    account: ReturnType<typeof AccountString>;
+    history: z.ZodUnion<[AccountHistoryZodType<T>, z.ZodLiteral<"">]>;
+    previous: z.ZodOptional<ReturnType<typeof HashString>>;
+}>>;
+export type AccountHistoryResponse<T extends UppercaseKeys<AccountHistoryResponseOptions>> = z.infer<AccountHistoryResponseZodType<T>>;
+export declare function AccountHistoryResponse<T extends AccountHistoryResponseOptions>(options: T): AccountHistoryResponseZodType<UppercaseKeys<T>>;
+export {};

package/dist/nano/rpc/responses/account-history.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountHistoryEntryRaw = AccountHistoryEntryRaw;
+exports.AccountHistoryEntry = AccountHistoryEntry;
+exports.AccountHistoryResponse = AccountHistoryResponse;
+const zod_1 = require("zod");
+const account_1 = require("../../types/account");
+const amount_1 = require("../../types/amount");
+const boolean_1 = require("../../types/boolean");
+const hash_1 = require("../../types/hash");
+const height_1 = require("../../types/height");
+const link_1 = require("../../types/link");
+const signature_1 = require("../../types/signature");
+const timestamp_1 = require("../../types/timestamp");
+const type_1 = require("../../types/type");
+const work_1 = require("../../types/work");
+const BaseBlockHistory = () => zod_1.z.object({
+    local_timestamp: (0, timestamp_1.TimestampString)(),
+    height: (0, height_1.HeightString)(),
+    hash: (0, hash_1.HashString)(),
+    confirmed: (0, boolean_1.BooleanString)(),
+    work: (0, work_1.WorkString)(),
+    signature: (0, signature_1.SignatureString)(),
+});
+const BaseStateBlockHistory = () => BaseBlockHistory().extend({
+    type: (0, type_1.StateTypeString)(),
+    previous: (0, hash_1.HashString)(),
+    representative: (0, account_1.AccountString)(),
+    balance: (0, amount_1.RawAmountString)(),
+    link: (0, link_1.LinkString)(),
+});
+const ChangeStateBlockHistory = () => BaseStateBlockHistory().extend({
+    subtype: zod_1.z.literal("change"),
+    // No account property here
+});
+const EpochStateBlockHistory = () => BaseStateBlockHistory().extend({
+    subtype: zod_1.z.literal("epoch"),
+    account: (0, account_1.AccountString)(), // Epoch Signer
+});
+const ReceiveStateBlockHistory = () => BaseStateBlockHistory().extend({
+    subtype: zod_1.z.literal("receive"),
+    account: (0, account_1.AccountString)().optional(), // TODO: if request.source_account == true
+    amount: (0, amount_1.RawAmountString)(),
+});
+const SendStateBlockHistory = () => BaseStateBlockHistory().extend({
+    subtype: zod_1.z.literal("send"),
+    account: (0, account_1.AccountString)(),
+    amount: (0, amount_1.RawAmountString)(),
+});
+const UnknownStateBlockHistory = () => BaseStateBlockHistory().extend({
+    subtype: zod_1.z.literal("unknown"),
+});
+const LegacyChangeBlockHistory = () => BaseBlockHistory().extend({
+    type: (0, type_1.LegacyChangeTypeString)(),
+    representative: (0, account_1.AccountString)(),
+    previous: (0, hash_1.HashString)(),
+});
+const LegacyOpenBlockHistory = () => BaseBlockHistory().extend({
+    type: (0, type_1.LegacyOpenTypeString)(),
+    representative: (0, account_1.AccountString)(),
+    source: (0, hash_1.HashString)(),
+    opened: (0, account_1.AccountString)(),
+    account: (0, account_1.AccountString)(),
+    amount: (0, amount_1.RawAmountString)(),
+});
+const LegacyReceiveBlockHistory = () => BaseBlockHistory().extend({
+    type: (0, type_1.LegacyReceiveTypeString)(),
+    account: (0, account_1.AccountString)(),
+    amount: (0, amount_1.RawAmountString)(),
+    source: (0, hash_1.HashString)(),
+    previous: (0, hash_1.HashString)(),
+});
+const LegacySendBlockHistory = () => BaseBlockHistory().extend({
+    type: (0, type_1.LegacySendTypeString)(),
+    account: (0, account_1.AccountString)(),
+    amount: (0, amount_1.RawAmountString)(),
+    destination: (0, account_1.AccountString)(),
+    balance: (0, amount_1.RawAmountString)(),
+    previous: (0, hash_1.HashString)(),
+});
+function AccountHistoryEntryRaw(options) {
+    return options.include_linked_account
+        ? zod_1.z.union([
+            ChangeStateBlockHistory().extend({ linked_account: (0, account_1.AccountString)().or(zod_1.z.literal("0")) }),
+            EpochStateBlockHistory().extend({ linked_account: (0, account_1.AccountString)().or(zod_1.z.literal("0")) }),
+            ReceiveStateBlockHistory().extend({ linked_account: (0, account_1.AccountString)().or(zod_1.z.literal("0")) }),
+            SendStateBlockHistory().extend({ linked_account: (0, account_1.AccountString)().or(zod_1.z.literal("0")) }),
+            UnknownStateBlockHistory().extend({ linked_account: (0, account_1.AccountString)().or(zod_1.z.literal("0")) }),
+            LegacyChangeBlockHistory().extend({ linked_account: (0, account_1.AccountString)().or(zod_1.z.literal("0")) }),
+            LegacyOpenBlockHistory().extend({ linked_account: (0, account_1.AccountString)().or(zod_1.z.literal("0")) }),
+            LegacyReceiveBlockHistory().extend({ linked_account: (0, account_1.AccountString)().or(zod_1.z.literal("0")) }),
+            LegacySendBlockHistory().extend({ linked_account: (0, account_1.AccountString)().or(zod_1.z.literal("0")) }),
+        ])
+        : zod_1.z.union([
+            ChangeStateBlockHistory(),
+            EpochStateBlockHistory(),
+            ReceiveStateBlockHistory(),
+            SendStateBlockHistory(),
+            UnknownStateBlockHistory(),
+            LegacyChangeBlockHistory(),
+            LegacyOpenBlockHistory(),
+            LegacyReceiveBlockHistory(),
+            LegacySendBlockHistory(),
+        ]);
+}
+const AccountHistoryEntryNotRaw = () => zod_1.z.object({
+    type: zod_1.z.literal("send").or(zod_1.z.literal("receive")),
+    account: (0, account_1.AccountString)(),
+    amount: (0, amount_1.RawAmountString)(),
+    local_timestamp: (0, timestamp_1.TimestampString)(),
+    height: (0, height_1.HeightString)(),
+    hash: (0, hash_1.HashString)(),
+    confirmed: (0, boolean_1.BooleanString)(),
+});
+function AccountHistoryEntry(options) {
+    return options.raw
+        ? AccountHistoryEntryRaw({
+            include_linked_account: options.include_linked_account,
+        })
+        : AccountHistoryEntryNotRaw().extend(options.include_linked_account ? { linked_account: (0, account_1.AccountString)().or(zod_1.z.literal("0")) } : {});
+}
+function AccountHistory(options) {
+    return AccountHistoryEntry(options).array();
+}
+function AccountHistoryResponse(options) {
+    return options.reverse
+        ? zod_1.z.object({
+            account: (0, account_1.AccountString)(),
+            history: AccountHistory({
+                include_linked_account: options.include_linked_account,
+                raw: options.raw,
+            }).or(zod_1.z.literal("")),
+            next: (0, hash_1.HashString)().optional(),
+        })
+        : zod_1.z.object({
+            account: (0, account_1.AccountString)(),
+            history: AccountHistory({
+                include_linked_account: options.include_linked_account,
+                raw: options.raw,
+            }).or(zod_1.z.literal("")),
+            previous: (0, hash_1.HashString)().optional(),
+        });
+}