# Entry

Entry is a single sided ledger booking that serves as the core ledger component; it is sparsely populated based on the entry type and the goal of the entry

## Example Usage

```typescript
import { Entry } from "@apexfintechsolutions/ascend-sdk/models/components";

let value: Entry = {};
```

## Fields

| Field                                                                                                                                                                                                                                                                                                                                 | Type                                                                                                                                                                                                                                                                                                                                  | Required                                                                                                                                                                                                                                                                                                                              | Description                                                                                                                                                                                                                                                                                                                           | Example                                                                                                                                                                                                                                                                                                                               |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `acatsPendingOut`                                                                                                                                                                                                                                                                                                                     | [components.AcatsPendingOut](../../models/components/acatspendingout.md)                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the movement of funds or shares to/ from the pending_acats memo location                                                                                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                       |
| `accountId`                                                                                                                                                                                                                                                                                                                           | *string*                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | A globally unique identifier referencing a single account; this is the main identifier for an account used for machine-to-machine interactions                                                                                                                                                                                        | 01HBRQ5BW6ZAY4BNWP4GWRD80X                                                                                                                                                                                                                                                                                                            |
| `accountMemo`                                                                                                                                                                                                                                                                                                                         | [components.AccountMemo](../../models/components/accountmemo.md)                                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Indicates the memo location impacted by an entry                                                                                                                                                                                                                                                                                      | FREE                                                                                                                                                                                                                                                                                                                                  |
| `accountTransfer`                                                                                                                                                                                                                                                                                                                     | [components.AccountTransfer](../../models/components/accounttransfer.md)                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the movement of funds or shares during the bookkeeping phase of an account transfer and details related to the account transfer                                                                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                       |
| `accruedInterest`                                                                                                                                                                                                                                                                                                                     | [components.EntryAccruedInterest](../../models/components/entryaccruedinterest.md)                                                                                                                                                                                                                                                    | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Indicates that the entry references accrued interest that has been earned but not yet paid between the last interest payment and the date of the trade                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                       |
| `acquisition`                                                                                                                                                                                                                                                                                                                         | [components.Acquisition](../../models/components/acquisition.md)                                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Object containing metadata for acquisition events                                                                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                       |
| `activityDate`                                                                                                                                                                                                                                                                                                                        | [components.ActivityDate](../../models/components/activitydate.md)                                                                                                                                                                                                                                                                    | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | The activity date refers to the specific calendar day on which a financial transaction, such as a trade at an exchange or a deposit at a bank, was executed. This date is specific to the institution where the transaction took place, capturing the exact day on which the institution formally records and effects the transaction | {<br/>"day": 14,<br/>"month": 5,<br/>"year": 2024<br/>}                                                                                                                                                                                                                                                                               |
| `activityId`                                                                                                                                                                                                                                                                                                                          | *string*                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Apex-generated unique activity identifier                                                                                                                                                                                                                                                                                             | 01YPBW4QX6R                                                                                                                                                                                                                                                                                                                           |
| `activityTime`                                                                                                                                                                                                                                                                                                                        | [Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)                                                                                                                                                                                                                                         | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Activity time refers to the precise moment, recorded in Coordinated Universal Time (UTC), when a financial transaction is executed as reported to Apex                                                                                                                                                                                | 2023-12-22T05:00:00Z                                                                                                                                                                                                                                                                                                                  |
| `allocation`                                                                                                                                                                                                                                                                                                                          | [components.Allocation](../../models/components/allocation.md)                                                                                                                                                                                                                                                                        | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Object containing metadata for trade allocation                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                                                                                       |
| `assetId`                                                                                                                                                                                                                                                                                                                             | *string*                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | An Apex-provided, global identifier created on a per asset bases which provides connectivity across all areas Required, except for currency movements which should instead have a currency_asset_id                                                                                                                                   | 1000                                                                                                                                                                                                                                                                                                                                  |
| `bondDefault`                                                                                                                                                                                                                                                                                                                         | [components.BondDefault](../../models/components/bonddefault.md)                                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Object containing metadata for bond defaults                                                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                       |
| `capitalGains`                                                                                                                                                                                                                                                                                                                        | [components.CapitalGains](../../models/components/capitalgains.md)                                                                                                                                                                                                                                                                    | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record a distribution of cash that an issuer has determined will be declared as income financed from capital gains and not ordinary income and details related to the capital gain                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                       |
| `cashDividend`                                                                                                                                                                                                                                                                                                                        | [components.CashDividend](../../models/components/cashdividend.md)                                                                                                                                                                                                                                                                    | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the distribution of cash to shareholders, paid by the issuer, usually based upon current earnings and/or accumulated profits as declared by the board of directors and details related to the cash dividend                                                                                                            |                                                                                                                                                                                                                                                                                                                                       |
| `cashInLieu`                                                                                                                                                                                                                                                                                                                          | [components.CashInLieu](../../models/components/cashinlieu.md)                                                                                                                                                                                                                                                                        | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Object containing metadata for cash in lieu                                                                                                                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                       |
| `commission`                                                                                                                                                                                                                                                                                                                          | [components.EntryCommission](../../models/components/entrycommission.md)                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Indicates that the entry references commission charged by brokers or financial intermediaries for executing financial transactions on behalf of clients                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                       |
| `conversion`                                                                                                                                                                                                                                                                                                                          | [components.Conversion](../../models/components/conversion.md)                                                                                                                                                                                                                                                                        | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the conversion of securities (generally convertible bonds or preferred shares) into another form of securities (usually common shares) at a pre-stated price or rate and details related to the conversion                                                                                                             |                                                                                                                                                                                                                                                                                                                                       |
| `corporateActionMemoAdjustment`                                                                                                                                                                                                                                                                                                       | [components.CorporateActionMemoAdjustment](../../models/components/corporateactionmemoadjustment.md)                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Object containing metadata for memo locations that have been adjusted due to a corporate action                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                                                                                       |
| `credit`                                                                                                                                                                                                                                                                                                                              | [components.Credit](../../models/components/credit.md)                                                                                                                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to disburse funds into a customer's account, typically for purposes such as refunds, interest payments, or rewards from enrolled programs and details related to the credit                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                       |
| `currencyAssetId`                                                                                                                                                                                                                                                                                                                     | *string*                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | The asset_id of the currency that all monetary values relate to Required for currency movements                                                                                                                                                                                                                                       | 1                                                                                                                                                                                                                                                                                                                                     |
| `delivery`                                                                                                                                                                                                                                                                                                                            | [components.Delivery](../../models/components/delivery.md)                                                                                                                                                                                                                                                                            | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Object containing metadata for delivery events                                                                                                                                                                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                       |
| `deposit`                                                                                                                                                                                                                                                                                                                             | [components.Deposit](../../models/components/deposit.md)                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record deposits of funds into an account and capture details related to the deposit                                                                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                       |
| `description`                                                                                                                                                                                                                                                                                                                         | *string*                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | A plain text description of the entry; will not be available to search on or build other features off of                                                                                                                                                                                                                              | Ascend trade posted via the booking-api                                                                                                                                                                                                                                                                                               |
| `drip`                                                                                                                                                                                                                                                                                                                                | [components.Drip](../../models/components/drip.md)                                                                                                                                                                                                                                                                                    | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the movement of funds to/ from the pending_drip memo location                                                                                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                       |
| `entryId`                                                                                                                                                                                                                                                                                                                             | *string*                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | The unique id of the entry                                                                                                                                                                                                                                                                                                            | 5a305880-eee4-4da9-9867-02c4f74732aa                                                                                                                                                                                                                                                                                                  |
| `eventContractSettlement`                                                                                                                                                                                                                                                                                                             | [components.EventContractSettlement](../../models/components/eventcontractsettlement.md)                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the settlement/payout of event contracts based on real-world event outcomes                                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                       |
| `exchange`                                                                                                                                                                                                                                                                                                                            | [components.Exchange](../../models/components/exchange.md)                                                                                                                                                                                                                                                                            | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the exchange of certificates for a new security or cash and details related to the exchange                                                                                                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                       |
| `fee`                                                                                                                                                                                                                                                                                                                                 | [components.EntryFee](../../models/components/entryfee.md)                                                                                                                                                                                                                                                                            | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record Fees that have been assessed to account and capture details related to the fee                                                                                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                       |
| `flip`                                                                                                                                                                                                                                                                                                                                | [components.Flip](../../models/components/flip.md)                                                                                                                                                                                                                                                                                    | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Object containing metadata for a Flip                                                                                                                                                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                       |
| `fpsl`                                                                                                                                                                                                                                                                                                                                | [components.Fpsl](../../models/components/fpsl.md)                                                                                                                                                                                                                                                                                    | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the movements of shares to/ from the fpsl memo location and details related to the fpsl memo                                                                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                       |
| `grossAmount`                                                                                                                                                                                                                                                                                                                         | [components.EntryGrossAmount](../../models/components/entrygrossamount.md)                                                                                                                                                                                                                                                            | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | The monetary value of an activity, exclusive of any fees (First money)                                                                                                                                                                                                                                                                | {<br/>"value": "0.25"<br/>}                                                                                                                                                                                                                                                                                                           |
| `interest`                                                                                                                                                                                                                                                                                                                            | [components.Interest](../../models/components/interest.md)                                                                                                                                                                                                                                                                            | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the payment of interest to accounts that have maintained a cash balance or the charging of interest to accounts that have used margin and details related to the interest                                                                                                                                              |                                                                                                                                                                                                                                                                                                                                       |
| `interestPayment`                                                                                                                                                                                                                                                                                                                     | [components.InterestPayment](../../models/components/interestpayment.md)                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the The payment of an obligation an issuer has agreed to make to holders of an interest-bearing security and details related to the interest payment. Usually, the payment is made in cash and on a scheduled basis                                                                                                    |                                                                                                                                                                                                                                                                                                                                       |
| `liquidation`                                                                                                                                                                                                                                                                                                                         | [components.Liquidation](../../models/components/liquidation.md)                                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the dismantling of a business by an issuer, paying off debts in order of priority and distributing the remaining assets in cash and/or securities to the owners of the securities and details related to the liquidation                                                                                               |                                                                                                                                                                                                                                                                                                                                       |
| `maturity`                                                                                                                                                                                                                                                                                                                            | [components.Maturity](../../models/components/maturity.md)                                                                                                                                                                                                                                                                            | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record he final repayment, usually in cash, by an issuer for the entire issue, or remaining outstanding securities of a specific security on a specified date and details related to the maturity                                                                                                                             |                                                                                                                                                                                                                                                                                                                                       |
| `merger`                                                                                                                                                                                                                                                                                                                              | [components.Merger](../../models/components/merger.md)                                                                                                                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the exchange of one company's security for another company's security, cash, or a combination of cash and securities and details related to the merger                                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                       |
| `name`                                                                                                                                                                                                                                                                                                                                | *string*                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | accounts/{account_id}/entries/{entry_id}                                                                                                                                                                                                                                                                                              | accounts/{account_id}/entries/{entry_id}                                                                                                                                                                                                                                                                                              |
| `nameChange`                                                                                                                                                                                                                                                                                                                          | [components.NameChange](../../models/components/namechange.md)                                                                                                                                                                                                                                                                        | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record changes in the name of a security/securities by the issuer which result in surrendering physical securities or the assigning of a new security identifier which result in new securities being issued and details related to the name changes                                                                          |                                                                                                                                                                                                                                                                                                                                       |
| `originalId`                                                                                                                                                                                                                                                                                                                          | *string*                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | The original entry id; stable across reversals and corrections; use for maintaining lineage of entries through multiple corrections/reversals                                                                                                                                                                                         | 454ca2f3-56fc-4ed9-9a8e-ac4df332f5d8                                                                                                                                                                                                                                                                                                  |
| `originalProcessDate`                                                                                                                                                                                                                                                                                                                 | [components.OriginalProcessDate](../../models/components/originalprocessdate.md)                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | The original entry process date; stable across reversals and corrections; use for maintaining lineage of entries through multiple corrections/reversals                                                                                                                                                                               | {<br/>"day": 14,<br/>"month": 5,<br/>"year": 2024<br/>}                                                                                                                                                                                                                                                                               |
| `originatingResourceName`                                                                                                                                                                                                                                                                                                             | *string*                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | The resource name of the API resource that originated this ledger entry or activity. This field enables clients to link ledger activities back to their source transactions for reconciliation purposes. This field will only be populated when the client has direct access to the referenced resource via the Ascend API's.         | booking/v1/accounts/{account_id}/trades/{trade_id}                                                                                                                                                                                                                                                                                    |
| `paymentInKind`                                                                                                                                                                                                                                                                                                                       | [components.PaymentInKind](../../models/components/paymentinkind.md)                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record payments on interest-bearing securities where the payment is made in additional securities rather than cash and details related to the payment                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                       |
| `price`                                                                                                                                                                                                                                                                                                                               | [components.EntryPrice](../../models/components/entryprice.md)                                                                                                                                                                                                                                                                        | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | The monetary value paid for a given security in a trade Required, except for currency movements                                                                                                                                                                                                                                       | {<br/>"value": "0.25"<br/>}                                                                                                                                                                                                                                                                                                           |
| `processDate`                                                                                                                                                                                                                                                                                                                         | [components.EntryProcessDate](../../models/components/entryprocessdate.md)                                                                                                                                                                                                                                                            | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | The date that the entry was booked on                                                                                                                                                                                                                                                                                                 | {<br/>"day": 14,<br/>"month": 5,<br/>"year": 2024<br/>}                                                                                                                                                                                                                                                                               |
| `quantity`                                                                                                                                                                                                                                                                                                                            | [components.EntryQuantity](../../models/components/entryquantity.md)                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | The quantity of shares bought, sold, or moved. For entries/ activities involving Fixed Income assets, quantity is expressed as par value Required for trades and memos, optional for movements.                                                                                                                                       | {<br/>"value": "0.25"<br/>}                                                                                                                                                                                                                                                                                                           |
| `receive`                                                                                                                                                                                                                                                                                                                             | [components.Receive](../../models/components/receive.md)                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Object containing metadata for receive events                                                                                                                                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                       |
| `redemptionFull`                                                                                                                                                                                                                                                                                                                      | [components.RedemptionFull](../../models/components/redemptionfull.md)                                                                                                                                                                                                                                                                | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the redemption of a security for cash in its entirety for which the holders receive the principal amount of the security and details related to the redemption                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                       |
| `redemptionPartial`                                                                                                                                                                                                                                                                                                                   | [components.RedemptionPartial](../../models/components/redemptionpartial.md)                                                                                                                                                                                                                                                          | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used when securities are redeemed by the issuer for cash, in part, before their scheduled maturity date and details related to the redemption. The outstanding amount of securities will be proportionally reduced based on a specific percentage of holding                                                                          |                                                                                                                                                                                                                                                                                                                                       |
| `reverseStockSplit`                                                                                                                                                                                                                                                                                                                   | [components.ReverseStockSplit](../../models/components/reversestocksplit.md)                                                                                                                                                                                                                                                          | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the exchange of a company's security for the same company's new security at a preset rate and details related to the reverse stock split                                                                                                                                                                               |                                                                                                                                                                                                                                                                                                                                       |
| `reversedEntryId`                                                                                                                                                                                                                                                                                                                     | *string*                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | The entry_id of the original entry; only populated on entries with a status of "Reversal"                                                                                                                                                                                                                                             | 5b806009-421a-4a63-b861-0416a32543f8                                                                                                                                                                                                                                                                                                  |
| `rightsDistribution`                                                                                                                                                                                                                                                                                                                  | [components.RightsDistribution](../../models/components/rightsdistribution.md)                                                                                                                                                                                                                                                        | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record distributions to common stock holders of a company that grant the option to purchase new or additional securities of the same company during a predetermined time period at a predetermined price and details related to the rights distribution                                                                       |                                                                                                                                                                                                                                                                                                                                       |
| `rightsSubscription`                                                                                                                                                                                                                                                                                                                  | [components.RightsSubscription](../../models/components/rightssubscription.md)                                                                                                                                                                                                                                                        | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the purchase of new or additional securities and details related to the subscription. Rights are often tradable in a secondary market                                                                                                                                                                                  |                                                                                                                                                                                                                                                                                                                                       |
| `roundingAdjustment`                                                                                                                                                                                                                                                                                                                  | [components.RoundingAdjustment](../../models/components/roundingadjustment.md)                                                                                                                                                                                                                                                        | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record rounding adjustments when the sum(price x quantity) of all entries for a given activity do not equal the price x quantity of the fully formed activity record                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                       |
| `saleOfRights`                                                                                                                                                                                                                                                                                                                        | [components.SaleOfRights](../../models/components/saleofrights.md)                                                                                                                                                                                                                                                                    | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record payments made by the issuer to security holders when the security is subject to redemptions other than full and partial calls (e.g., early CD redemptions) and details related to the sale of rights                                                                                                                   |                                                                                                                                                                                                                                                                                                                                       |
| `settleDate`                                                                                                                                                                                                                                                                                                                          | [components.SettleDate](../../models/components/settledate.md)                                                                                                                                                                                                                                                                        | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | The date a given entry/ activity will officially settle                                                                                                                                                                                                                                                                               | {<br/>"day": 14,<br/>"month": 5,<br/>"year": 2024<br/>}                                                                                                                                                                                                                                                                               |
| `side`                                                                                                                                                                                                                                                                                                                                | [components.EntrySide](../../models/components/entryside.md)                                                                                                                                                                                                                                                                          | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Denotes whether the trade is a buy or sell                                                                                                                                                                                                                                                                                            | BUY                                                                                                                                                                                                                                                                                                                                   |
| `sideModifier`                                                                                                                                                                                                                                                                                                                        | [components.EntrySideModifier](../../models/components/entrysidemodifier.md)                                                                                                                                                                                                                                                          | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Indicates whether the trade is opening a new position or closing an existing position Should be populated if possible for trades; the side modifier for the trade                                                                                                                                                                     | OPEN                                                                                                                                                                                                                                                                                                                                  |
| `spinOff`                                                                                                                                                                                                                                                                                                                             | [components.SpinOff](../../models/components/spinoff.md)                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record a distribution of subsidiary securities to the shareholders of the parent company without a surrender of securities or payment and details related to the spinoff. A spin-off represents a form of divestiture resulting in an independent company                                                                     |                                                                                                                                                                                                                                                                                                                                       |
| `state`                                                                                                                                                                                                                                                                                                                               | [components.EntryState](../../models/components/entrystate.md)                                                                                                                                                                                                                                                                        | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Set to be NEW for BookEntries, other statuses will be assigned via ModifyActivities; the state of the entry                                                                                                                                                                                                                           | NEW                                                                                                                                                                                                                                                                                                                                   |
| `stockDividend`                                                                                                                                                                                                                                                                                                                       | [components.StockDividend](../../models/components/stockdividend.md)                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record a dividend paid to shareholders in the form of shares of stock in either the issuing company or in another company and details related to the stock dividend                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                       |
| `stockSplit`                                                                                                                                                                                                                                                                                                                          | [components.StockSplit](../../models/components/stocksplit.md)                                                                                                                                                                                                                                                                        | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the increase in a company's number of outstanding shares of stock without any change in the shareholder's equity or the aggregate market value at the time of the split and details related to the stock split                                                                                                         |                                                                                                                                                                                                                                                                                                                                       |
| `subtypeCategory`                                                                                                                                                                                                                                                                                                                     | *string*                                                                                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | String representation of the metadata object containing more information about an entry/activity                                                                                                                                                                                                                                      | FEE                                                                                                                                                                                                                                                                                                                                   |
| `sweep`                                                                                                                                                                                                                                                                                                                               | [components.Sweep](../../models/components/sweep.md)                                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record sweeps from a cash balance to an alternative asset or vice versa and details related to the sweep                                                                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                       |
| `tenderOffer`                                                                                                                                                                                                                                                                                                                         | [components.TenderOffer](../../models/components/tenderoffer.md)                                                                                                                                                                                                                                                                      | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the sale of securities for a specified price due to an offer from the issuer or a third party and details related to the tender offer                                                                                                                                                                                  |                                                                                                                                                                                                                                                                                                                                       |
| `trade`                                                                                                                                                                                                                                                                                                                               | [components.EntryTrade](../../models/components/entrytrade.md)                                                                                                                                                                                                                                                                        | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the the execution of a buy or sell transaction resulting in the transfer of securities and corresponding payment and details related to the trade                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                                       |
| `transfer`                                                                                                                                                                                                                                                                                                                            | [components.EntryTransfer](../../models/components/entrytransfer.md)                                                                                                                                                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record more generic transfers of funds or securities and details related to the transfer. The transfer type and activity_description can be used to provide more specific context                                                                                                                                             |                                                                                                                                                                                                                                                                                                                                       |
| `type`                                                                                                                                                                                                                                                                                                                                | [components.EntryType](../../models/components/entrytype.md)                                                                                                                                                                                                                                                                          | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | The Type of the entry; determines the set of mandatory fields as well as informing downstream processes how to handle this record                                                                                                                                                                                                     | TRADE                                                                                                                                                                                                                                                                                                                                 |
| `unitSplit`                                                                                                                                                                                                                                                                                                                           | [components.UnitSplit](../../models/components/unitsplit.md)                                                                                                                                                                                                                                                                          | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record increases in the number of units outstanding through the issuing of more units to current shareholders and details related to the unit split                                                                                                                                                                           |                                                                                                                                                                                                                                                                                                                                       |
| `warrantExercise`                                                                                                                                                                                                                                                                                                                     | [components.WarrantExercise](../../models/components/warrantexercise.md)                                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the exchange of warrants for shares and details related to the warrant exercise. The exercise will commonly require a payment based upon a pre-determined value and time and details related to the warrant exercise                                                                                                   |                                                                                                                                                                                                                                                                                                                                       |
| `withdrawal`                                                                                                                                                                                                                                                                                                                          | [components.Withdrawal](../../models/components/withdrawal.md)                                                                                                                                                                                                                                                                        | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record withdrawals of funds from an account and capture details related to the withdrawal                                                                                                                                                                                                                                     |                                                                                                                                                                                                                                                                                                                                       |
| `withdrawalPendingReview`                                                                                                                                                                                                                                                                                                             | [components.WithdrawalPendingReview](../../models/components/withdrawalpendingreview.md)                                                                                                                                                                                                                                              | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the movement of funds to/ from the pending_withdrawal memo location                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                                       |
| `withholding`                                                                                                                                                                                                                                                                                                                         | [components.EntryWithholding](../../models/components/entrywithholding.md)                                                                                                                                                                                                                                                            | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record tax withholdings and details related to the withholding                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                                                                                                       |
| `worthless`                                                                                                                                                                                                                                                                                                                           | [components.Worthless](../../models/components/worthless.md)                                                                                                                                                                                                                                                                          | :heavy_minus_sign:                                                                                                                                                                                                                                                                                                                    | Used to record the removal of positions in a given security when the DTC has received formal notice that the security is worthless and details related to the worthless event                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                                       |