query BankTransfer($bankTransfer: BankTransferMatchInput!) {
  bankTransfer(bankTransfer: $bankTransfer) {
    description
    id
    order {
      ...OrderFragment
    }
    status
  }
}

{"bankTransfer": BankTransferMatchInput}

{
  "data": {
    "bankTransfer": {
      "description": "xyz789",
      "id": 4,
      "order": Order,
      "status": "failed"
    }
  }
}

query Ledger($ledger: LedgerMatchInput!) {
  ledger(ledger: $ledger) {
    balanceUTCOffset
    created
    id
    ik
    ledgerAccounts {
      ...LedgerAccountsConnectionFragment
    }
    ledgerEntries {
      ...LedgerEntriesConnectionFragment
    }
    migrations {
      ...LedgerMigrationConnectionFragment
    }
    name
    schema {
      ...SchemaFragment
    }
    type
    workspaceId
  }
}

{"ledger": LedgerMatchInput}

{
  "data": {
    "ledger": {
      "balanceUTCOffset": UTCOffset,
      "created": "2007-12-03T10:15:30Z",
      "id": 4,
      "ik": "some-safe-string-ik",
      "ledgerAccounts": LedgerAccountsConnection,
      "ledgerEntries": LedgerEntriesConnection,
      "migrations": LedgerMigrationConnection,
      "name": "xyz789",
      "schema": Schema,
      "type": "double",
      "workspaceId": "4"
    }
  }
}

query LedgerAccount($ledgerAccount: LedgerAccountMatchInput!) {
  ledgerAccount(ledgerAccount: $ledgerAccount) {
    balance
    balanceChange
    balanceChanges {
      ...CurrencyAmountConnectionFragment
    }
    balances {
      ...CurrencyAmountConnectionFragment
    }
    childBalance
    childBalanceChange
    childBalanceChanges {
      ...CurrencyAmountConnectionFragment
    }
    childBalances {
      ...CurrencyAmountConnectionFragment
    }
    created
    currency {
      ...CurrencyFragment
    }
    currencyMode
    id
    ik
    ikPath
    ledger {
      ...LedgerFragment
    }
    ledgerId
    lines {
      ...LedgerLinesConnectionFragment
    }
    link {
      ...LinkFragment
    }
    linkedAccount {
      ...ExternalAccountFragment
    }
    name
    ownBalance
    ownBalanceChange
    ownBalances {
      ...CurrencyAmountConnectionFragment
    }
    parentLedgerAccount {
      ...LedgerAccountFragment
    }
    parentLedgerAccountId
    path
    type
    unreconciledTxs {
      ...TxsConnectionFragment
    }
    workspaceId
  }
}

{"ledgerAccount": LedgerAccountMatchInput}

{
  "data": {
    "ledgerAccount": {
      "balance": Int64,
      "balanceChange": Int64,
      "balanceChanges": CurrencyAmountConnection,
      "balances": CurrencyAmountConnection,
      "childBalance": Int64,
      "childBalanceChange": Int64,
      "childBalanceChanges": CurrencyAmountConnection,
      "childBalances": CurrencyAmountConnection,
      "created": "2007-12-03T10:15:30Z",
      "currency": Currency,
      "currencyMode": "multi",
      "id": 4,
      "ik": "xyz789",
      "ikPath": "abc123",
      "ledger": Ledger,
      "ledgerId": 4,
      "lines": LedgerLinesConnection,
      "link": Link,
      "linkedAccount": ExternalAccount,
      "name": "abc123",
      "ownBalance": Int64,
      "ownBalanceChange": Int64,
      "ownBalances": CurrencyAmountConnection,
      "parentLedgerAccount": LedgerAccount,
      "parentLedgerAccountId": "4",
      "path": "xyz789",
      "type": "asset",
      "unreconciledTxs": TxsConnection,
      "workspaceId": "4"
    }
  }
}

query LedgerEntry($ledgerEntry: LedgerEntryMatchInput!) {
  ledgerEntry(ledgerEntry: $ledgerEntry) {
    created
    date
    description
    id
    ledger {
      ...LedgerFragment
    }
    ledgerId
    lines {
      ...LedgerLinesConnectionFragment
    }
    order {
      ...OrderFragment
    }
    orderId
    posted
    workspaceId
  }
}

{"ledgerEntry": LedgerEntryMatchInput}

{
  "data": {
    "ledgerEntry": {
      "created": "2007-12-03T10:15:30Z",
      "date": "2007-12-03",
      "description": "abc123",
      "id": 4,
      "ledger": Ledger,
      "ledgerId": "4",
      "lines": LedgerLinesConnection,
      "order": Order,
      "orderId": 4,
      "posted": "2007-12-03T10:15:30Z",
      "workspaceId": 4
    }
  }
}

query LedgerLine($ledgerLine: LedgerLineMatchInput!) {
  ledgerLine(ledgerLine: $ledgerLine) {
    account {
      ...LedgerAccountFragment
    }
    accountId
    amount
    created
    currency {
      ...CurrencyFragment
    }
    date
    description
    externalTransferId
    externalTransferType
    externalTxId
    id
    ledger {
      ...LedgerFragment
    }
    ledgerEntryId
    ledgerId
    otherTxExternalAccountExternalId
    otherTxExternalAccountId
    otherTxExternalId
    otherTxId
    posted
    txId
    type
    workspaceId
  }
}

{"ledgerLine": LedgerLineMatchInput}

{
  "data": {
    "ledgerLine": {
      "account": LedgerAccount,
      "accountId": "4",
      "amount": Int64,
      "created": "2007-12-03T10:15:30Z",
      "currency": Currency,
      "date": "2007-12-03",
      "description": "xyz789",
      "externalTransferId": "xyz789",
      "externalTransferType": "ach",
      "externalTxId": "xyz789",
      "id": 4,
      "ledger": Ledger,
      "ledgerEntryId": 4,
      "ledgerId": "4",
      "otherTxExternalAccountExternalId": "xyz789",
      "otherTxExternalAccountId": "xyz789",
      "otherTxExternalId": "xyz789",
      "otherTxId": "abc123",
      "posted": "2007-12-03T10:15:30Z",
      "txId": "xyz789",
      "type": "credit",
      "workspaceId": 4
    }
  }
}

query Ledgers(
  $after: String,
  $before: String,
  $filter: LedgersFilterSet,
  $first: Int,
  $last: Int
) {
  ledgers(
    after: $after,
    before: $before,
    filter: $filter,
    first: $first,
    last: $last
  ) {
    nodes {
      ...LedgerFragment
    }
    pageInfo {
      ...PageInfoFragment
    }
  }
}

{
  "after": "xyz789",
  "before": "abc123",
  "filter": LedgersFilterSet,
  "first": 987,
  "last": 123
}

{
  "data": {
    "ledgers": {
      "nodes": [Ledger],
      "pageInfo": PageInfo
    }
  }
}

query Order($order: OrderMatchInput!) {
  order(order: $order) {
    description
    entryIds
    id
    stateMachine {
      ...OrderStateMachineFragment
    }
  }
}

{"order": OrderMatchInput}

{
  "data": {
    "order": {
      "description": "abc123",
      "entryIds": ["abc123"],
      "id": 4,
      "stateMachine": OrderStateMachine
    }
  }
}

query Schema($schema: SchemaMatchInput!) {
  schema(schema: $schema) {
    key
    ledgers {
      ...LedgersConnectionFragment
    }
    schemaVersion {
      ...SchemaVersionFragment
    }
    versions {
      ...SchemaVersionConnectionFragment
    }
  }
}

{"schema": SchemaMatchInput}

{
  "data": {
    "schema": {
      "key": "some-safe-string-ik",
      "ledgers": LedgersConnection,
      "schemaVersion": SchemaVersion,
      "versions": SchemaVersionConnection
    }
  }
}

query Schemas {
  schemas {
    nodes {
      ...SchemaFragment
    }
    pageInfo {
      ...PageInfoFragment
    }
  }
}

{
  "data": {
    "schemas": {
      "nodes": [Schema],
      "pageInfo": PageInfo
    }
  }
}

query Tx($tx: TxMatchInput!) {
  tx(tx: $tx) {
    accountId
    amount
    currency {
      ...CurrencyFragment
    }
    date
    description
    externalAccountId
    externalId
    id
    ledgerEntries {
      ...LedgerEntriesConnectionFragment
    }
    ledgerEntryIds
    ledgerLineIds
    ledgerLines {
      ...LedgerLinesConnectionFragment
    }
    linkId
    posted
    workspaceId
  }
}

{"tx": TxMatchInput}

{
  "data": {
    "tx": {
      "accountId": 4,
      "amount": Int64,
      "currency": Currency,
      "date": "2007-12-03",
      "description": "xyz789",
      "externalAccountId": 4,
      "externalId": "4",
      "id": "4",
      "ledgerEntries": LedgerEntriesConnection,
      "ledgerEntryIds": ["4"],
      "ledgerLineIds": ["4"],
      "ledgerLines": LedgerLinesConnection,
      "linkId": 4,
      "posted": "2007-12-03T10:15:30Z",
      "workspaceId": "4"
    }
  }
}

mutation AddLedgerEntry(
  $entry: LedgerEntryInput!,
  $ik: SafeString!
) {
  addLedgerEntry(
    entry: $entry,
    ik: $ik
  ) {
    ... on AddLedgerEntryResult {
      ...AddLedgerEntryResultFragment
    }
    ... on BadRequestError {
      ...BadRequestErrorFragment
    }
    ... on InternalError {
      ...InternalErrorFragment
    }
  }
}

{"entry": LedgerEntryInput, "ik": "some-safe-string-ik"}

{"data": {"addLedgerEntry": AddLedgerEntryResult}}

mutation CreateCustomCurrency($customCurrency: CreateCustomCurrencyInput!) {
  createCustomCurrency(customCurrency: $customCurrency) {
    ... on BadRequestError {
      ...BadRequestErrorFragment
    }
    ... on CreateCustomCurrencyResult {
      ...CreateCustomCurrencyResultFragment
    }
    ... on InternalError {
      ...InternalErrorFragment
    }
  }
}

{"customCurrency": CreateCustomCurrencyInput}

{"data": {"createCustomCurrency": BadRequestError}}

mutation CreateCustomLink(
  $ik: SafeString!,
  $name: String!
) {
  createCustomLink(
    ik: $ik,
    name: $name
  ) {
    ... on BadRequestError {
      ...BadRequestErrorFragment
    }
    ... on CreateCustomLinkResult {
      ...CreateCustomLinkResultFragment
    }
    ... on InternalError {
      ...InternalErrorFragment
    }
  }
}

{
  "ik": "some-safe-string-ik",
  "name": "xyz789"
}

{"data": {"createCustomLink": BadRequestError}}

mutation CreateLedger(
  $ik: SafeString!,
  $ledger: CreateLedgerInput!,
  $schema: SchemaMatchInput
) {
  createLedger(
    ik: $ik,
    ledger: $ledger,
    schema: $schema
  ) {
    ... on BadRequestError {
      ...BadRequestErrorFragment
    }
    ... on CreateLedgerResult {
      ...CreateLedgerResultFragment
    }
    ... on InternalError {
      ...InternalErrorFragment
    }
  }
}

{
  "ik": "some-safe-string-ik",
  "ledger": CreateLedgerInput,
  "schema": SchemaMatchInput
}

{"data": {"createLedger": BadRequestError}}

mutation CreateLedgerAccount(
  $ik: SafeString!,
  $ledger: LedgerMatchInput!,
  $ledgerAccount: CreateLedgerAccountInput!
) {
  createLedgerAccount(
    ik: $ik,
    ledger: $ledger,
    ledgerAccount: $ledgerAccount
  ) {
    ... on BadRequestError {
      ...BadRequestErrorFragment
    }
    ... on CreateLedgerAccountResult {
      ...CreateLedgerAccountResultFragment
    }
    ... on InternalError {
      ...InternalErrorFragment
    }
  }
}

{
  "ik": "some-safe-string-ik",
  "ledger": LedgerMatchInput,
  "ledgerAccount": CreateLedgerAccountInput
}

{"data": {"createLedgerAccount": BadRequestError}}

mutation CreateLedgerAccounts(
  $ledger: LedgerMatchInput!,
  $ledgerAccounts: [CreateLedgerAccountsInput!]!
) {
  createLedgerAccounts(
    ledger: $ledger,
    ledgerAccounts: $ledgerAccounts
  ) {
    ... on BadRequestError {
      ...BadRequestErrorFragment
    }
    ... on CreateLedgerAccountsResult {
      ...CreateLedgerAccountsResultFragment
    }
    ... on InternalError {
      ...InternalErrorFragment
    }
  }
}

{
  "ledger": LedgerMatchInput,
  "ledgerAccounts": [CreateLedgerAccountsInput]
}

{"data": {"createLedgerAccounts": BadRequestError}}

mutation CreateOrder(
  $ik: SafeString!,
  $order: CreateOrderInput!
) {
  createOrder(
    ik: $ik,
    order: $order
  ) {
    ... on BadRequestError {
      ...BadRequestErrorFragment
    }
    ... on CreateOrderResult {
      ...CreateOrderResultFragment
    }
    ... on InternalError {
      ...InternalErrorFragment
    }
  }
}

{"ik": "some-safe-string-ik", "order": CreateOrderInput}

{"data": {"createOrder": BadRequestError}}

mutation MakeBankTransfer(
  $bankTransfer: MakeBankTransferInput!,
  $ik: SafeString!
) {
  makeBankTransfer(
    bankTransfer: $bankTransfer,
    ik: $ik
  ) {
    ... on BadRequestError {
      ...BadRequestErrorFragment
    }
    ... on InternalError {
      ...InternalErrorFragment
    }
    ... on MakeBankTransferResult {
      ...MakeBankTransferResultFragment
    }
  }
}

{
  "bankTransfer": MakeBankTransferInput,
  "ik": "some-safe-string-ik"
}

{"data": {"makeBankTransfer": BadRequestError}}

mutation ReconcileTx($entry: LedgerEntryInput!) {
  reconcileTx(entry: $entry) {
    ... on BadRequestError {
      ...BadRequestErrorFragment
    }
    ... on InternalError {
      ...InternalErrorFragment
    }
    ... on ReconcileTxResult {
      ...ReconcileTxResultFragment
    }
  }
}

{"entry": LedgerEntryInput}

{"data": {"reconcileTx": BadRequestError}}

mutation StoreSchema($schema: SchemaInput!) {
  storeSchema(schema: $schema) {
    ... on BadRequestError {
      ...BadRequestErrorFragment
    }
    ... on InternalError {
      ...InternalErrorFragment
    }
    ... on StoreSchemaResult {
      ...StoreSchemaResultFragment
    }
  }
}

{"schema": SchemaInput}

{"data": {"storeSchema": BadRequestError}}

mutation SyncCustomAccounts(
  $accounts: [CustomAccountInput!]!,
  $link: LinkMatchInput!
) {
  syncCustomAccounts(
    accounts: $accounts,
    link: $link
  ) {
    ... on BadRequestError {
      ...BadRequestErrorFragment
    }
    ... on InternalError {
      ...InternalErrorFragment
    }
    ... on SyncCustomAccountsResult {
      ...SyncCustomAccountsResultFragment
    }
  }
}

{
  "accounts": [CustomAccountInput],
  "link": LinkMatchInput
}

{"data": {"syncCustomAccounts": BadRequestError}}

mutation SyncCustomTxs(
  $link: LinkMatchInput!,
  $txs: [CustomTxInput!]!
) {
  syncCustomTxs(
    link: $link,
    txs: $txs
  ) {
    ... on BadRequestError {
      ...BadRequestErrorFragment
    }
    ... on InternalError {
      ...InternalErrorFragment
    }
    ... on SyncCustomTxsResult {
      ...SyncCustomTxsResultFragment
    }
  }
}

{
  "link": LinkMatchInput,
  "txs": [CustomTxInput]
}

{"data": {"syncCustomTxs": BadRequestError}}

mutation UpdateLedger(
  $ledger: LedgerMatchInput!,
  $update: UpdateLedgerInput!
) {
  updateLedger(
    ledger: $ledger,
    update: $update
  ) {
    ... on BadRequestError {
      ...BadRequestErrorFragment
    }
    ... on InternalError {
      ...InternalErrorFragment
    }
    ... on UpdateLedgerResult {
      ...UpdateLedgerResultFragment
    }
  }
}

{
  "ledger": LedgerMatchInput,
  "update": UpdateLedgerInput
}

{"data": {"updateLedger": BadRequestError}}

mutation UpdateLedgerAccount(
  $ledgerAccount: LedgerAccountMatchInput!,
  $update: UpdateLedgerAccountInput!
) {
  updateLedgerAccount(
    ledgerAccount: $ledgerAccount,
    update: $update
  ) {
    ... on BadRequestError {
      ...BadRequestErrorFragment
    }
    ... on InternalError {
      ...InternalErrorFragment
    }
    ... on UpdateLedgerAccountResult {
      ...UpdateLedgerAccountResultFragment
    }
  }
}

{
  "ledgerAccount": LedgerAccountMatchInput,
  "update": UpdateLedgerAccountInput
}

{"data": {"updateLedgerAccount": BadRequestError}}

AddLedgerEntryResult

{
  "entry": LedgerEntry,
  "isIkReplay": true,
  "lines": [LedgerLine]
}

{
  "code": "abc123",
  "message": "xyz789",
  "retryable": false
}

{
  "description": "abc123",
  "id": "4",
  "order": Order,
  "status": "failed"
}

{"id": 4}

{
  "status": "failed",
  "transitionLog": [BankTransferStateMachineTransitionLog]
}

{"transitions": BankTransferStateMachineTransitionsInput}

{"entry": LedgerEntry}

{"entry": LedgerEntryInput}

{"config": BankTransferStateMachineConfigInput}

"failed"

"failed_to_submitted"

{
  "effect": BankTransferStateMachineEffect,
  "timestamp": "2007-12-03T10:15:30Z",
  "transition": "failed_to_submitted"
}

{
  "failed_to_submitted": BankTransferStateMachineEffectInput,
  "on_submitted": BankTransferStateMachineEffectInput,
  "returned_to_submitted": BankTransferStateMachineEffectInput,
  "settled_to_returned": BankTransferStateMachineEffectInput,
  "submitted_to_failed": BankTransferStateMachineEffectInput,
  "submitted_to_settled": BankTransferStateMachineEffectInput
}

true

{
  "customCode": "xyz789",
  "customCurrencyId": "some-safe-string-ik",
  "name": "abc123",
  "precision": 123
}

BadRequestError

{"customCurrency": Currency}

BadRequestError

{"isIkReplay": false, "link": Link}

{
  "currency": CurrencyMatchInput,
  "currencyMode": "multi",
  "linkedAccount": ExternalAccountMatchInput,
  "name": "xyz789",
  "parent": LedgerAccountMatchInput,
  "type": "asset"
}

BadRequestError

{"isIkReplay": true, "ledgerAccount": LedgerAccount}

{
  "childLedgerAccounts": [CreateLedgerAccountsInput],
  "currency": CurrencyMatchInput,
  "currencyMode": "multi",
  "ik": "some-safe-string-ik",
  "linkedAccount": ExternalAccountMatchInput,
  "name": "abc123",
  "parent": LedgerAccountMatchInput,
  "type": "asset"
}

BadRequestError

{
  "ikReplays": [IkReplay],
  "ledgerAccounts": [LedgerAccount]
}

{
  "balanceUTCOffset": UTCOffset,
  "name": "xyz789",
  "type": "double"
}

BadRequestError

{"isIkReplay": false, "ledger": Ledger}

{
  "description": "abc123",
  "entry": LedgerEntryInput,
  "stateMachine": CreateOrderStateMachineInput
}

BadRequestError

{
  "entry": LedgerEntry,
  "isIkReplay": false,
  "lines": [LedgerLine],
  "order": Order
}

{"bankTransfer": BankTransferStateMachineInput}

{
  "code": "AAVE",
  "customCode": "abc123",
  "customCurrencyId": "some-safe-string-ik",
  "name": "xyz789",
  "precision": 987
}

{
  "amount": Int64,
  "currency": Currency
}

{
  "nodes": [CurrencyAmount],
  "pageInfo": PageInfo
}

"AAVE"

{"code": "AAVE", "customCurrencyId": "some-safe-string-ik"}

"multi"

{
  "currency": CurrencyMatchInput,
  "currencyMode": "multi",
  "externalId": "some-safe-string-ik",
  "name": "xyz789"
}

{
  "created": "abc123",
  "id": 4,
  "name": "xyz789"
}

{
  "account": ExternalAccountMatchInput,
  "amount": Int64,
  "currency": CurrencyMatchInput,
  "description": "abc123",
  "externalId": "some-safe-string-ik",
  "posted": "2007-12-03T10:15:30Z"
}

"2007-12-03"

{
  "equalTo": "2007-12-03",
  "in": ["2007-12-03"]
}

"2007-12-03T10:15:30Z"

{
  "after": "2007-12-03T10:15:30Z",
  "before": "2007-12-03T10:15:30Z"
}

{
  "code": "xyz789",
  "message": "xyz789",
  "retryable": true
}

{
  "currency": Currency,
  "currencyMode": "multi",
  "externalId": 4,
  "id": 4,
  "linkId": "4",
  "name": "abc123"
}

{
  "equalTo": ExternalAccountMatchInput,
  "in": [ExternalAccountMatchInput]
}

{"externalId": 4, "id": 4, "linkId": 4}

"ach"

4

{"ik": "some-safe-string-ik", "isIkReplay": true}

"production"

{
  "created": "abc123",
  "id": "4",
  "increaseEnv": "production",
  "name": "xyz789"
}

{"wire": IncreaseWirePaymentDetailsInput}

{
  "beneficiaryAddressLine1": "abc123",
  "beneficiaryAddressLine2": "abc123",
  "beneficiaryAddressLine3": "xyz789",
  "beneficiaryName": "xyz789"
}

123

Int64

{
  "code": "abc123",
  "message": "abc123",
  "retryable": true
}

LastMoment

{
  "balanceUTCOffset": UTCOffset,
  "created": "2007-12-03T10:15:30Z",
  "id": 4,
  "ik": "some-safe-string-ik",
  "ledgerAccounts": LedgerAccountsConnection,
  "ledgerEntries": LedgerEntriesConnection,
  "migrations": LedgerMigrationConnection,
  "name": "abc123",
  "schema": Schema,
  "type": "double",
  "workspaceId": "4"
}

{
  "balance": Int64,
  "balanceChange": Int64,
  "balanceChanges": CurrencyAmountConnection,
  "balances": CurrencyAmountConnection,
  "childBalance": Int64,
  "childBalanceChange": Int64,
  "childBalanceChanges": CurrencyAmountConnection,
  "childBalances": CurrencyAmountConnection,
  "created": "2007-12-03T10:15:30Z",
  "currency": Currency,
  "currencyMode": "multi",
  "id": "4",
  "ik": "abc123",
  "ikPath": "abc123",
  "ledger": Ledger,
  "ledgerId": 4,
  "lines": LedgerLinesConnection,
  "link": Link,
  "linkedAccount": ExternalAccount,
  "name": "abc123",
  "ownBalance": Int64,
  "ownBalanceChange": Int64,
  "ownBalances": CurrencyAmountConnection,
  "parentLedgerAccount": LedgerAccount,
  "parentLedgerAccountId": "4",
  "path": "xyz789",
  "type": "asset",
  "unreconciledTxs": TxsConnection,
  "workspaceId": 4
}

{
  "equalTo": LedgerAccountMatchInput,
  "in": [LedgerAccountMatchInput]
}

{
  "id": "4",
  "ikPath": "xyz789",
  "ledger": LedgerMatchInput
}

{"equalTo": "asset", "in": ["asset"]}

"asset"

{
  "nodes": [LedgerAccount],
  "pageInfo": PageInfo
}

{
  "hasParentLedgerAccount": true,
  "isLinkedAccount": false,
  "ledgerAccount": LedgerAccountFilter,
  "linkedAccount": ExternalAccountFilter,
  "parentLedgerAccount": LedgerAccountFilter,
  "type": LedgerAccountTypeFilter
}

{
  "nodes": [LedgerEntry],
  "pageInfo": PageInfo
}

{
  "date": DateFilter,
  "posted": DateTimeFilter
}

{
  "created": "2007-12-03T10:15:30Z",
  "date": "2007-12-03",
  "description": "abc123",
  "id": 4,
  "ledger": Ledger,
  "ledgerId": 4,
  "lines": LedgerLinesConnection,
  "order": Order,
  "orderId": "4",
  "posted": "2007-12-03T10:15:30Z",
  "workspaceId": 4
}

{
  "description": "abc123",
  "lines": [LedgerLineInput],
  "posted": "2007-12-03T10:15:30Z"
}

{"id": 4}

{
  "account": LedgerAccount,
  "accountId": "4",
  "amount": Int64,
  "created": "2007-12-03T10:15:30Z",
  "currency": Currency,
  "date": "2007-12-03",
  "description": "abc123",
  "externalTransferId": "abc123",
  "externalTransferType": "ach",
  "externalTxId": "xyz789",
  "id": "4",
  "ledger": Ledger,
  "ledgerEntryId": 4,
  "ledgerId": 4,
  "otherTxExternalAccountExternalId": "abc123",
  "otherTxExternalAccountId": "xyz789",
  "otherTxExternalId": "xyz789",
  "otherTxId": "abc123",
  "posted": "2007-12-03T10:15:30Z",
  "txId": "abc123",
  "type": "credit",
  "workspaceId": 4
}

{
  "account": LedgerAccountMatchInput,
  "amount": Int64,
  "currency": CurrencyMatchInput,
  "description": "xyz789",
  "payment": PaymentInput,
  "tx": TxMatchInput
}

{"id": "4"}

{
  "nodes": [LedgerLine],
  "pageInfo": PageInfo
}

{
  "date": DateFilter,
  "posted": DateTimeFilter,
  "type": TxTypeFilter
}

{"id": 4, "ik": "some-safe-string-ik"}

{
  "ledger": Ledger,
  "schemaVersion": SchemaVersion,
  "status": "completed"
}

{
  "nodes": [LedgerMigration],
  "pageInfo": PageInfo
}

"completed"

{"equalTo": "double", "in": ["double"]}

"double"

{
  "nodes": [Ledger],
  "pageInfo": PageInfo
}

{"type": LedgerTypeFilter}

{
  "created": "abc123",
  "id": "4",
  "name": "abc123"
}

{"id": "4"}

{
  "amount": Int64,
  "description": "xyz789",
  "linkedLedgerAccount": LedgerAccountMatchInput,
  "offset": LedgerEntryInput,
  "payment": PaymentInput
}

BadRequestError

{"bankTransfer": BankTransfer, "isIkReplay": true}

{
  "description": "xyz789",
  "entryIds": ["abc123"],
  "id": "4",
  "stateMachine": OrderStateMachine
}

{"id": "4"}

{"bankTransfer": BankTransferStateMachine}

{
  "endCursor": "abc123",
  "hasNextPage": false,
  "hasPreviousPage": true,
  "startCursor": "abc123"
}

{
  "accountNumber": "abc123",
  "externalAccount": ExternalAccountMatchInput,
  "routingNumber": "xyz789"
}

{"increase": IncreasePaymentDetailsInput}

{
  "description": "xyz789",
  "destination": PayeeInput,
  "details": PaymentDetailsInput,
  "source": PayeeInput,
  "type": "ach"
}

"ach"

Period

BadRequestError

{
  "entry": LedgerEntry,
  "isIkReplay": true,
  "lines": [LedgerLine]
}

"some-safe-string-ik"

{
  "key": "some-safe-string-ik",
  "ledgers": LedgersConnection,
  "schemaVersion": SchemaVersion,
  "versions": SchemaVersionConnection
}

{
  "nodes": [Schema],
  "pageInfo": PageInfo
}

{"key": "some-safe-string-ik"}

{"key": "some-safe-string-ik", "version": 987}

{"migrations": LedgerMigrationConnection, "version": 123}

{
  "nodes": [SchemaVersion],
  "pageInfo": PageInfo
}

BadRequestError

{"schema": Schema}

"xyz789"

BadRequestError

{"accounts": [ExternalAccount]}

BadRequestError

{"txs": [Tx]}

{
  "accountId": 4,
  "amount": Int64,
  "currency": Currency,
  "date": "2007-12-03",
  "description": "xyz789",
  "externalAccountId": "4",
  "externalId": 4,
  "id": "4",
  "ledgerEntries": LedgerEntriesConnection,
  "ledgerEntryIds": [4],
  "ledgerLineIds": ["4"],
  "ledgerLines": LedgerLinesConnection,
  "linkId": "4",
  "posted": "2007-12-03T10:15:30Z",
  "workspaceId": "4"
}

{
  "accountId": "4",
  "externalAccountId": "4",
  "externalId": 4,
  "id": "4",
  "linkId": 4
}

"credit"

{"equalTo": "credit", "in": ["credit"]}

{
  "nodes": [Tx],
  "pageInfo": PageInfo
}

UTCOffset

{"name": "xyz789"}

BadRequestError

{"ledgerAccount": LedgerAccount}

{"name": "abc123"}

BadRequestError

{"ledger": Ledger}