models

type Account = mmodel.Account

type AccountFilter struct {
	// Status is a list of status codes to filter by
	Status []string `json:"status,omitempty"`
}

type AccountRule = mmodel.AccountRule

type AccountType = mmodel.AccountType

type Accounts struct {
	// Items is the collection of accounts in the current page
	Items []Account `json:"items"`

	// Page is the current page number
	Page int `json:"page"`

	// Limit is the maximum number of items per page
	Limit int `json:"limit"`
}

type Address struct {
	// Line1 is the primary address line (e.g., street number and name)
	Line1 string `json:"line1"`

	// Line2 is an optional secondary address line (e.g., apartment or suite number)
	Line2 *string `json:"line2,omitempty"`

	// ZipCode is the postal or ZIP code
	ZipCode string `json:"zipCode"`

	// City is the city or locality name
	City string `json:"city"`

	// State is the state, province, or region
	State string `json:"state"`

	// Country is the country, typically using ISO country codes
	Country string `json:"country"`
}

type Amount struct {
	// The amount value in the smallest unit of the asset (e.g., cents)
	// example: 1500
	// minimum: 0
	Value *decimal.Decimal `json:"value" example:"1500" minimum:"0"`

} // @name Amount

type AmountInput struct {
	// Asset identifies the currency or asset type for this amount
	Asset string `json:"asset"`

	// Value is the numeric value of the amount as a decimal string
	Value string `json:"value"`
}

type Asset = mmodel.Asset

type Balance = mmodel.Balance

type BaseResponse struct {
	// RequestID is a unique identifier for the API request
	// This can be used for troubleshooting and support
	RequestID string `json:"requestId,omitempty"`
}

type CreateAccountInput struct {
	// Name is the human-readable name of the account.
	// Max length: 256 characters.
	Name string `json:"name"`

	// ParentAccountID is the ID of the parent account, if this is a sub-account.
	// Must be a valid UUID if provided.
	ParentAccountID *string `json:"parentAccountId,omitempty"`

	// EntityID is an optional external identifier for the account owner.
	// Max length: 256 characters.
	EntityID *string `json:"entityId,omitempty"`

	// AssetCode identifies the type of asset held in this account.
	// Required. Max length: 100 characters.
	AssetCode string `json:"assetCode"`

	// PortfolioID is the optional ID of the portfolio this account belongs to.
	// Must be a valid UUID if provided.
	PortfolioID *string `json:"portfolioId,omitempty"`

	// SegmentID is the optional ID of the segment this account belongs to.
	// Must be a valid UUID if provided.
	SegmentID *string `json:"segmentId,omitempty"`

	// Status represents the current status of the account (e.g., "ACTIVE", "CLOSED").
	Status Status `json:"status"`

	// Alias is an optional human-friendly identifier for the account.
	// Max length: 100 characters.
	Alias *string `json:"alias,omitempty"`

	// Type defines the account type (e.g., "ASSET", "LIABILITY", "EQUITY").
	// Required.
	Type string `json:"type"`

	// Metadata contains additional custom data associated with the account.
	// Keys max length: 100 characters, Values max length: 2000 characters.
	Metadata map[string]any `json:"metadata,omitempty"`
}

type CreateAccountTypeInput struct {
	mmodel.CreateAccountTypeInput
}

type CreateAssetInput struct {
	mmodel.CreateAssetInput
}

type CreateLedgerInput struct {
	mmodel.CreateLedgerInput
}

type CreateOperationInput struct {
	// Type indicates whether this is a debit or credit operation
	// Must be either "debit" or "credit"
	Type string `json:"type"`

	// AccountID is the identifier of the account to be affected
	// This must be a valid account ID in the ledger
	AccountID string `json:"accountId"`

	// Amount is the numeric value of the operation as a decimal string
	// Examples: "100.50", "1000.00", "0.25"
	Amount string `json:"amount"`

	// AssetCode identifies the currency or asset type for this operation
	// Common examples include "USD", "EUR", "BTC", etc.
	AssetCode string `json:"assetCode,omitempty"`

	// AccountAlias is an optional human-readable name for the account
	// This can be used to reference accounts by their alias instead of ID
	// Format is typically "<type>:<identifier>[:subtype]", e.g., "customer:john.doe"
	AccountAlias *string `json:"accountAlias,omitempty"`

	// Route is the operation route identifier to use for this operation
	// This links the operation to a specific routing rule that determines
	// how the operation should be processed and what account rules to apply
	Route string `json:"route,omitempty"`
}

type CreateOperationRouteInput struct {
	mmodel.CreateOperationRouteInput
}

type CreateOrganizationInput struct {
	mmodel.CreateOrganizationInput
}

type CreatePortfolioInput struct {
	mmodel.CreatePortfolioInput
}

type CreateSegmentInput struct {
	mmodel.CreateSegmentInput
}

type CreateTransactionInput struct {
	// Template is an optional identifier for the transaction template to use
	// Templates can be used to create standardized transactions with predefined
	// structures and validation rules
	// Note: This is used for SDK logic but not sent in the API request
	Template string

	// Amount is the numeric value of the transaction as a decimal string
	// This represents the total value of the transaction (e.g., "100.50" for $100.50)
	// Note: This is used for validation but sent within the Send structure
	Amount string

	// AssetCode identifies the currency or asset type for this transaction
	// Common examples include "USD", "EUR", "BTC", etc.
	// Note: This is used for validation but sent within the Send structure
	AssetCode string

	// Operations contains the individual debit and credit operations
	// Each operation represents a single accounting entry (debit or credit)
	// The sum of all operations for each asset must balance to zero
	// Note: Operations are an alternative to Send and should not be serialized when Send is used
	Operations []CreateOperationInput

	// ChartOfAccountsGroupName is REQUIRED by the API specification
	// This categorizes the transaction under a specific chart of accounts group
	ChartOfAccountsGroupName string `json:"chartOfAccountsGroupName"`

	// Description is a human-readable description of the transaction (REQUIRED by API)
	// This should provide context about the purpose or nature of the transaction
	Description string `json:"description"`

	// Pending indicates whether the transaction should be created in a pending state
	// Pending transactions require explicit commitment before affecting account balances
	Pending bool `json:"pending,omitempty"`

	// Route is the transaction route identifier (optional)
	// This defines the overall flow of the transaction structure
	Route string `json:"route,omitempty"`

	// Metadata contains additional custom data for the transaction
	// This can be used to store application-specific information
	// such as references to external systems, tags, or other contextual data
	Metadata map[string]any `json:"metadata,omitempty"`

	// ExternalID is an optional identifier for linking to external systems
	// This can be used to correlate transactions with records in other systems
	// and to prevent duplicate transactions
	// Note: This is handled separately, not in request body for Send format
	ExternalID string

	// IdempotencyKey is a client-generated key to ensure transaction uniqueness
	// If a transaction with the same idempotency key already exists, that transaction
	// will be returned instead of creating a new one
	// Note: This is sent as a header (X-Idempotency), not in the request body
	IdempotencyKey string

	// Send contains the source and distribution information for the transaction (REQUIRED by API)
	// This is an alternative to using Operations and provides a more structured way
	// to define the transaction flow
	Send *SendInput `json:"send"`
}

type CreateTransactionRouteInput struct {
	mmodel.CreateTransactionRouteInput
}

type DSLAccountRef struct {
	Account string
}

type DSLAmount struct {
	// Value is the numeric value of the amount as a decimal string
	Value string `json:"value"`

	// Asset is the asset code for the amount
	Asset string `json:"asset,omitempty"`
}

type DSLDistribute struct {
	// Remaining is an optional remaining account
	Remaining string `json:"remaining,omitempty"`

	// To is a collection of destination accounts and amounts
	To []DSLFromTo `json:"to"`
}

type DSLFromTo struct {
	// Account is the identifier of the account
	Account string `json:"account"`

	// Amount specifies the amount details if applicable
	Amount *DSLAmount `json:"amount,omitempty"`

	// Share is the sharing configuration
	Share *Share `json:"share,omitempty"`

	// Remaining is an optional remaining account
	Remaining string `json:"remaining,omitempty"`

	// Rate is the exchange rate configuration
	Rate *Rate `json:"rate,omitempty"`

	// Description is a human-readable description
	Description string `json:"description,omitempty"`

	// ChartOfAccounts is the chart of accounts code
	ChartOfAccounts string `json:"chartOfAccounts,omitempty"`

	// Metadata contains additional custom data
	Metadata map[string]any `json:"metadata,omitempty"`
}

type DSLSend struct {
	// Asset identifies the currency or asset type for this transaction
	Asset string `json:"asset"`

	// Value is the numeric value of the transaction as a decimal string
	Value string `json:"value"`

	// Source specifies where the funds come from
	Source *DSLSource `json:"source,omitempty"`

	// Distribute specifies where the funds go to
	Distribute *DSLDistribute `json:"distribute,omitempty"`
}

type DSLSource struct {
	// Remaining is an optional remaining account
	Remaining string `json:"remaining,omitempty"`

	// From is a collection of source accounts and amounts
	From []DSLFromTo `json:"from"`
}

type Destination struct {
	// ID is the unique identifier for the destination account
	ID string `json:"id"`

	// Alias is an optional human-readable name for the destination account
	Alias *string `json:"alias,omitempty"`

	// Source indicates if this destination is also a source
	Source bool `json:"source"`
}

type DistributeInput struct {
	// To contains the list of destination accounts and amounts
	To []FromToInput `json:"to"`
}

type ErrorResponse struct {
	// Error is the error message
	Error string `json:"error"`

	// Code is the error code for programmatic handling
	Code string `json:"code,omitempty"`

	// Details contains additional information about the error
	Details map[string]any `json:"details,omitempty"`
}

type FromToInput struct {
	// Account identifies the account affected by this operation
	Account string `json:"account"`

	// Amount specifies the amount details for this operation
	Amount AmountInput `json:"amount"`

	// Route is the operation route identifier for this operation (optional)
	// This links the operation to a specific routing rule
	Route string `json:"route,omitempty"`

	// Description provides additional context for this operation (optional)
	Description string `json:"description,omitempty"`

	// ChartOfAccounts specifies the chart of accounts for this operation (optional)
	ChartOfAccounts string `json:"chartOfAccounts,omitempty"`

	// AccountAlias provides an alternative account identifier (optional)
	AccountAlias string `json:"accountAlias,omitempty"`

	// Metadata contains additional custom data for this operation
	Metadata map[string]any `json:"metadata,omitempty"`
}

type Ledger = mmodel.Ledger

type ListAccountInput struct {
	// Page is the page number to retrieve
	Page int `json:"page,omitempty"`

	// PerPage is the number of items per page
	PerPage int `json:"perPage,omitempty"`

	// Filter contains the filtering criteria
	Filter AccountFilter `json:"filter,omitempty"`
}

type ListAccountResponse struct {
	// Items is the collection of accounts in the current page
	Items []Account `json:"items"`

	// Total is the total number of accounts matching the criteria
	Total int `json:"total"`

	// CurrentPage is the current page number
	CurrentPage int `json:"currentPage"`

	// PageSize is the number of items per page
	PageSize int `json:"pageSize"`

	// TotalPages is the total number of pages
	TotalPages int `json:"totalPages"`
}

type ListOptions struct {
	// Limit is the maximum number of items to return per page
	Limit int `json:"limit,omitempty"`

	// Offset is the starting position for pagination
	Offset int `json:"offset,omitempty"`

	// Filters are additional filters to apply to the query
	// The map keys are filter names and values are the filter criteria
	Filters map[string]string `json:"filters,omitempty"`

	// OrderBy specifies the field to order results by
	OrderBy string `json:"orderBy,omitempty"`

	// OrderDirection is the order direction ("asc" for ascending or "desc" for descending)
	OrderDirection string `json:"orderDirection,omitempty"`

	// Page is the page number to return (when using page-based pagination)
	// This is kept for backward compatibility
	Page int `json:"page,omitempty"`

	// Cursor is the cursor for pagination (when using cursor-based pagination)
	// This is kept for backward compatibility
	Cursor string `json:"cursor,omitempty"`

	// StartDate and EndDate for filtering by date range
	// These should be in ISO 8601 format (YYYY-MM-DD)
	StartDate string `json:"startDate,omitempty"`
	EndDate   string `json:"endDate,omitempty"`

	// AdditionalParams contains additional parameters that are specific to certain endpoints
	// These parameters are not serialized to JSON but are used when making API requests
	AdditionalParams map[string]string `json:"-"`
}

type ListResponse[T any] struct {
	// Embedding BaseResponse to include common response fields
	BaseResponse

	// Items is the collection of resources returned by the list operation
	Items []T `json:"items"`

	// Pagination contains information about the pagination state
	Pagination Pagination `json:"pagination,omitempty"`
}

type Metadata map[string]any

type MetricsCount struct {
	// OrganizationsCount is the total number of organizations in the system
	OrganizationsCount int `json:"organizationsCount"`

	// LedgersCount is the total number of ledgers in the system
	LedgersCount int `json:"ledgersCount"`

	// AssetsCount is the total number of assets in the system
	AssetsCount int `json:"assetsCount"`

	// SegmentsCount is the total number of segments in the system
	SegmentsCount int `json:"segmentsCount"`

	// PortfoliosCount is the total number of portfolios in the system
	PortfoliosCount int `json:"portfoliosCount"`

	// AccountsCount is the total number of accounts in the system
	AccountsCount int `json:"accountsCount"`

	// TransactionsCount is the total number of transactions in the system
	TransactionsCount int `json:"transactionsCount"`

	// OperationsCount is the total number of operations in the system
	OperationsCount int `json:"operationsCount"`
}

type ObjectWithMetadata struct {
	// Metadata is a map of key-value pairs associated with the object
	Metadata map[string]any `json:"metadata,omitempty"`
}

type Operation struct {
	// Unique identifier for the operation
	// example: 00000000-0000-0000-0000-000000000000
	// format: uuid
	ID string `json:"id" example:"00000000-0000-0000-0000-000000000000" format:"uuid"`

	// Parent transaction identifier
	// example: 00000000-0000-0000-0000-000000000000
	// format: uuid
	TransactionID string `json:"transactionId" example:"00000000-0000-0000-0000-000000000000" format:"uuid"`

	// Human-readable description of the operation
	// example: Credit card operation
	// maxLength: 256
	Description string `json:"description" example:"Credit card operation" maxLength:"256"`

	// Type of operation (e.g., DEBIT, CREDIT)
	// example: DEBIT
	// maxLength: 50
	Type string `json:"type" example:"DEBIT" maxLength:"50"`

	// Asset code for the operation
	// example: BRL
	// minLength: 2
	// maxLength: 10
	AssetCode string `json:"assetCode" example:"BRL" minLength:"2" maxLength:"10"`

	// Chart of accounts code for accounting purposes
	// example: 1000
	// maxLength: 20
	ChartOfAccounts string `json:"chartOfAccounts" example:"1000" maxLength:"20"`

	// Operation amount information
	Amount Amount `json:"amount"`

	// Balance before the operation
	Balance OperationBalance `json:"balance"`

	// Balance after the operation
	BalanceAfter OperationBalance `json:"balanceAfter"`

	// Operation status information
	Status Status `json:"status"`

	// Account identifier associated with this operation
	// example: 00000000-0000-0000-0000-000000000000
	// format: uuid
	AccountID string `json:"accountId" example:"00000000-0000-0000-0000-000000000000" format:"uuid"`

	// Human-readable alias for the account
	// example: @person1
	// maxLength: 256
	AccountAlias string `json:"accountAlias" example:"@person1" maxLength:"256"`

	// Balance identifier affected by this operation
	// example: 00000000-0000-0000-0000-000000000000
	// format: uuid
	BalanceID string `json:"balanceId" example:"00000000-0000-0000-0000-000000000000" format:"uuid"`

	// Organization identifier
	// example: 00000000-0000-0000-0000-000000000000
	// format: uuid
	OrganizationID string `json:"organizationId" example:"00000000-0000-0000-0000-000000000000" format:"uuid"`

	// Ledger identifier
	// example: 00000000-0000-0000-0000-000000000000
	// format: uuid
	LedgerID string `json:"ledgerId" example:"00000000-0000-0000-0000-000000000000" format:"uuid"`

	// Route
	// example: 00000000-0000-0000-0000-000000000000
	// format: string
	Route string `json:"route" example:"00000000-0000-0000-0000-000000000000" format:"string"`

	// Timestamp when the operation was created
	// example: 2021-01-01T00:00:00Z
	// format: date-time
	CreatedAt time.Time `json:"createdAt" example:"2021-01-01T00:00:00Z" format:"date-time"`

	// Timestamp when the operation was last updated
	// example: 2021-01-01T00:00:00Z
	// format: date-time
	UpdatedAt time.Time `json:"updatedAt" example:"2021-01-01T00:00:00Z" format:"date-time"`

	// Timestamp when the operation was deleted (if soft-deleted)
	// example: 2021-01-01T00:00:00Z
	// format: date-time
	DeletedAt *time.Time `json:"deletedAt" example:"2021-01-01T00:00:00Z" format:"date-time"`

	// Additional custom attributes
	// example: {"reason": "Purchase refund", "reference": "INV-12345"}
	Metadata map[string]any `json:"metadata"`

} // @name Operation

type OperationAmount struct {
	// Value is the string representation of the amount
	Value string `json:"value"`
}

type OperationBalance struct {
	// Amount available for transactions (in the smallest unit of asset)
	// example: 1500
	// minimum: 0
	Available *decimal.Decimal `json:"available" example:"1500" minimum:"0"`

	// Amount on hold and unavailable for transactions (in the smallest unit of asset)
	// example: 500
	// minimum: 0
	OnHold *decimal.Decimal `json:"onHold" example:"500" minimum:"0"`

} // @name OperationBalance

type OperationLog struct {
	// Unique identifier for the operation
	// example: 00000000-0000-0000-0000-000000000000
	// format: uuid
	ID string `json:"id" example:"00000000-0000-0000-0000-000000000000" format:"uuid"`

	// Parent transaction identifier
	// example: 00000000-0000-0000-0000-000000000000
	// format: uuid
	TransactionID string `json:"transactionId" example:"00000000-0000-0000-0000-000000000000" format:"uuid"`

	// Type of operation (e.g., creditCard, transfer, payment)
	// example: creditCard
	// maxLength: 50
	Type string `json:"type" example:"creditCard" maxLength:"50"`

	// Asset code for the operation
	// example: BRL
	// minLength: 2
	// maxLength: 10
	AssetCode string `json:"assetCode" example:"BRL" minLength:"2" maxLength:"10"`

	// Chart of accounts code for accounting purposes
	// example: 1000
	// maxLength: 20
	ChartOfAccounts string `json:"chartOfAccounts" example:"1000" maxLength:"20"`

	// Operation amount information
	Amount Amount `json:"amount"`

	// Balance before the operation
	Balance OperationBalance `json:"balance"`

	// Balance after the operation
	BalanceAfter OperationBalance `json:"balanceAfter"`

	// Operation status information
	Status Status `json:"status"`

	// Account identifier associated with this operation
	// example: 00000000-0000-0000-0000-000000000000
	// format: uuid
	AccountID string `json:"accountId" example:"00000000-0000-0000-0000-000000000000" format:"uuid"`

	// Human-readable alias for the account
	// example: @person1
	// maxLength: 256
	AccountAlias string `json:"accountAlias" example:"@person1" maxLength:"256"`

	// Balance identifier affected by this operation
	// example: 00000000-0000-0000-0000-000000000000
	// format: uuid
	BalanceID string `json:"balanceId" example:"00000000-0000-0000-0000-000000000000" format:"uuid"`

	// Timestamp when the operation log was created
	// example: 2021-01-01T00:00:00Z
	// format: date-time
	CreatedAt time.Time `json:"createdAt" example:"2021-01-01T00:00:00Z" format:"date-time"`

	// Additional custom attributes for audit tracking
	// example: {"audit_user": "system", "source": "api"}
	Metadata map[string]any `json:"metadata"`

} // @name OperationLog

type OperationResponse struct {
	// in: body
	Body Operation
}

type OperationRoute = mmodel.OperationRoute

type OperationRouteInputType string

type OperationRouteType string

type OperationType string

type Operations struct {
	// Array of operation records returned in this page
	Items []Operation `json:"items"`

	// Pagination information
	Pagination struct {
		Limit      int     `json:"limit"`
		NextCursor *string `json:"next_cursor,omitempty"`
		PrevCursor *string `json:"prev_cursor,omitempty"`
	} `json:"pagination"`

} // @name Operations

type OperationsResponse struct {
	// in: body
	Body Operations
}

type Organization = mmodel.Organization

type Pagination struct {
	// Limit is the number of items per page
	Limit int `json:"limit"`

	// Offset is the starting position for the current page
	Offset int `json:"offset"`

	// Total is the total number of items available across all pages
	Total int `json:"total"`

	// PrevCursor is the cursor for the previous page (for cursor-based pagination)
	PrevCursor string `json:"prevCursor,omitempty"`

	// NextCursor is the cursor for the next page (for cursor-based pagination)
	NextCursor string `json:"nextCursor,omitempty"`
}

type Portfolio = mmodel.Portfolio

type Queue struct {
	// OrganizationID is the unique identifier of the organization that owns this queue
	OrganizationID uuid.UUID `json:"organizationId"`

	// LedgerID is the identifier of the ledger associated with this queue
	LedgerID uuid.UUID `json:"ledgerId"`

	// AuditID is the identifier for audit tracking purposes
	AuditID uuid.UUID `json:"auditId"`

	// AccountID is the identifier of the account associated with this queue
	AccountID uuid.UUID `json:"accountId"`

	// QueueData contains the collection of data items in this queue
	QueueData []QueueData `json:"queueData"`
}

type QueueData struct {
	// ID is the unique identifier for this queue data item
	ID uuid.UUID `json:"id"`

	// Value contains the actual data as raw JSON
	Value json.RawMessage `json:"value"`
}

type Rate struct {
	From       string `json:"from"`
	To         string `json:"to"`
	Value      string `json:"value"`
	ExternalID string `json:"externalId"`
}

type Segment = mmodel.Segment

type SendInput struct {
	// Asset identifies the currency or asset type for this transaction
	Asset string `json:"asset"`

	// Value is the numeric value of the transaction as a decimal string
	Value string `json:"value"`

	// Source contains the source accounts for the transaction
	Source *SourceInput `json:"source"`

	// Distribute contains the destination accounts for the transaction
	Distribute *DistributeInput `json:"distribute"`
}

type Share struct {
	Percentage             int64 `json:"percentage"`
	PercentageOfPercentage int64 `json:"percentageOfPercentage,omitempty"`
}

type SortDirection string

type Source struct {
	// ID is the unique identifier for the source account
	ID string `json:"id"`

	// Alias is an optional human-readable name for the source account
	Alias *string `json:"alias,omitempty"`

	// Destination indicates if this source is also a destination
	Destination bool `json:"destination"`
}

type SourceInput struct {
	// From contains the list of source accounts and amounts
	From []FromToInput `json:"from"`
}

type Status = mmodel.Status

type Timestamps struct {
	// CreatedAt is the timestamp when the resource was created
	CreatedAt time.Time `json:"createdAt"`

	// UpdatedAt is the timestamp when the resource was last updated
	UpdatedAt time.Time `json:"updatedAt"`

	// DeletedAt is the timestamp when the resource was deleted (if applicable)
	DeletedAt *time.Time `json:"deletedAt,omitempty"`
}

type Transaction struct {
	// ID is the unique identifier for the transaction
	// This is a system-generated UUID that uniquely identifies the transaction
	ID string `json:"id"`

	// Template is an optional identifier for the transaction template used
	// Templates can be used to create standardized transactions with predefined
	// structures and validation rules
	Template string `json:"template,omitempty"`

	// Amount is the numeric value of the transaction as a decimal string
	// This represents the total value of the transaction (e.g., "100.50" for $100.50)
	Amount string `json:"amount"`

	// AssetCode identifies the currency or asset type for this transaction
	// Common examples include "USD", "EUR", "BTC", etc.
	AssetCode string `json:"assetCode"`

	// Route is the transaction route identifier that defines the overall flow
	// of the transaction, including the structure of operations to be executed
	Route string `json:"route,omitempty"`

	// Status indicates the current processing status of the transaction
	// See the Status enum for possible values (PENDING, COMPLETED, FAILED, CANCELED)
	Status Status `json:"status"`

	// ChartOfAccountsGroupName specifies the chart of accounts group to use
	// This categorizes the transaction under a specific group for accounting purposes
	ChartOfAccountsGroupName string `json:"chartOfAccountsGroupName,omitempty"`

	// Source contains the list of source account aliases used in this transaction
	// These are the accounts from which funds are debited
	Source []string `json:"source,omitempty"`

	// Destination contains the list of destination account aliases used in this transaction
	// These are the accounts to which funds are credited
	Destination []string `json:"destination,omitempty"`

	// Pending indicates whether the transaction is in a pending state
	// Pending transactions require explicit commitment before affecting account balances
	Pending bool `json:"pending,omitempty"`

	// LedgerID identifies the ledger this transaction belongs to
	// A ledger is a collection of accounts and transactions within an organization
	LedgerID string `json:"ledgerId"`

	// OrganizationID identifies the organization this transaction belongs to
	// An organization is the top-level entity that owns ledgers and accounts
	OrganizationID string `json:"organizationId"`

	// Operations contains the individual debit and credit operations
	// Each operation represents a single accounting entry (debit or credit)
	// The sum of all operations for each asset must balance to zero
	Operations []Operation `json:"operations,omitempty"`

	// Metadata contains additional custom data for the transaction
	// This can be used to store application-specific information
	// such as references to external systems, tags, or other contextual data
	Metadata map[string]any `json:"metadata,omitempty"`

	// CreatedAt is the timestamp when the transaction was created
	CreatedAt time.Time `json:"createdAt"`

	// UpdatedAt is the timestamp when the transaction was last updated
	UpdatedAt time.Time `json:"updatedAt"`

	// DeletedAt is the timestamp when the transaction was deleted, if applicable
	// This field is only set if the transaction has been soft-deleted
	DeletedAt *time.Time `json:"deletedAt,omitempty"`

	// ExternalID is an optional identifier for linking to external systems
	// This can be used to correlate transactions with records in other systems
	// and to prevent duplicate transactions
	ExternalID string `json:"externalId,omitempty"`

	// Description is a human-readable description of the transaction
	// This should provide context about the purpose or nature of the transaction
	Description string `json:"description,omitempty"`
}

type TransactionDSLInput struct {
	// ChartOfAccountsGroupName specifies the chart of accounts group to use
	ChartOfAccountsGroupName string `json:"chartOfAccountsGroupName,omitempty"`

	// Description provides a human-readable description of the transaction
	Description string `json:"description,omitempty"`

	// Send contains the sending configuration
	Send *DSLSend `json:"send,omitempty"`

	// Metadata contains additional custom data for the transaction
	Metadata map[string]any `json:"metadata,omitempty"`

	// Code is a custom transaction code for categorization
	Code string `json:"code,omitempty"`

	// Pending indicates whether the transaction requires explicit commitment
	Pending bool `json:"pending,omitempty"`
}

type TransactionRoute = mmodel.TransactionRoute

type UpdateAccountInput struct {
	// Name is the human-readable name of the account.
	// Max length: 256 characters.
	Name string `json:"name"`

	// SegmentID is the optional ID of the segment this account belongs to.
	// Must be a valid UUID if provided.
	SegmentID *string `json:"segmentId,omitempty"`

	// PortfolioID is the optional ID of the portfolio this account belongs to.
	// Must be a valid UUID if provided.
	PortfolioID *string `json:"portfolioId,omitempty"`

	// Status represents the current status of the account (e.g., "ACTIVE", "CLOSED").
	Status Status `json:"status"`

	// Metadata contains additional custom data associated with the account.
	// Keys max length: 100 characters, Values max length: 2000 characters.
	Metadata map[string]any `json:"metadata,omitempty"`
}

type UpdateAccountTypeInput struct {
	mmodel.UpdateAccountTypeInput
}

type UpdateAssetInput struct {
	mmodel.UpdateAssetInput
}

type UpdateBalanceInput struct {
	// Metadata contains additional custom data associated with the balance.
	Metadata map[string]any `json:"metadata,omitempty"`
}

type UpdateLedgerInput struct {
	mmodel.UpdateLedgerInput
}

type UpdateOperationInput struct {
	// Human-readable description of the operation
	// example: Credit card operation
	// maxLength: 256
	Description string `json:"description" validate:"max=256" example:"Credit card operation" maxLength:"256"`

	// Additional custom attributes
	// example: {"reason": "Purchase refund", "reference": "INV-12345"}
	Metadata map[string]any `json:"metadata" validate:"dive,keys,keymax=100,endkeys,omitempty,nonested,valuemax=2000"`

} // @name UpdateOperationInput

type UpdateOperationRouteInput struct {
	mmodel.UpdateOperationRouteInput
}

type UpdateOrganizationInput struct {
	mmodel.UpdateOrganizationInput
}

type UpdatePortfolioInput struct {
	mmodel.UpdatePortfolioInput
}

type UpdateSegmentInput struct {
	mmodel.UpdateSegmentInput
}

type UpdateTransactionInput struct {
	// Metadata contains additional custom data for the transaction
	// This can be used to store application-specific information
	// such as references to external systems, tags, or other contextual data
	Metadata map[string]any `json:"metadata,omitempty"`

	// Description is a human-readable description of the transaction
	// This should provide context about the purpose or nature of the transaction
	Description string `json:"description,omitempty"`

	// ExternalID is an optional identifier for linking to external systems
	// This can be used to correlate transactions with records in other systems
	ExternalID string `json:"externalId,omitempty"`
}

type UpdateTransactionRouteInput struct {
	mmodel.UpdateTransactionRouteInput
}