@odatano/core 0.3.2 → 0.3.4

package/@cds-models/odatano/cardano/index.ts

@@ -0,0 +1,802 @@
+// This is an automatically generated file. Please do not change its contents manually!
+import * as __ from './../../_';
+import * as _ from './../..';
+
+export type Blake2b224 = string;
+export type Blake2b256 = string;
+export type HexBytes = string;
+export type Lovelace = number;
+export type AssetUnit = string;
+export type MetadataLabel = string;
+export type Bech32 = string;
+// enum
+export const SubmissionStatus = {
+  pending: "pending",
+  submitted: "submitted",
+  confirmed: "confirmed",
+  failed: "failed",
+} as const;
+export type SubmissionStatus = "pending" | "submitted" | "confirmed" | "failed"
+
+// enum
+export const SigningStatus = {
+  pending: "pending",
+  signed: "signed",
+  verified: "verified",
+  submitted: "submitted",
+  expired: "expired",
+  failed: "failed",
+} as const;
+export type SigningStatus = "pending" | "signed" | "verified" | "submitted" | "expired" | "failed"
+
+export function _AssetSliceAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class AssetSlice extends Base {
+    declare quantity?: Lovelace | null
+    declare policyId?: Blake2b224 | null
+    declare assetNameHex?: string | null
+    declare assetName?: string | null
+    declare fingerprint?: string | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'type';
+    declare static readonly keys: __.KeysOf<AssetSlice>;
+    declare static readonly elements: __.ElementsOf<AssetSlice>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class AssetSlice extends _AssetSliceAspect(__.Entity) {}
+Object.defineProperty(AssetSlice, 'name', { value: 'odatano.cardano.AssetSlice' })
+Object.defineProperty(AssetSlice, 'is_singular', { value: true })
+
+export function _MetadataSliceAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class MetadataSlice extends Base {
+    declare label?: MetadataLabel | null
+    declare payload?: string | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'type';
+    declare static readonly keys: __.KeysOf<MetadataSlice>;
+    declare static readonly elements: __.ElementsOf<MetadataSlice>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class MetadataSlice extends _MetadataSliceAspect(__.Entity) {}
+Object.defineProperty(MetadataSlice, 'name', { value: 'odatano.cardano.MetadataSlice' })
+Object.defineProperty(MetadataSlice, 'is_singular', { value: true })
+
+export function _UTxODataSliceAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class UTxODataSlice extends Base {
+    declare dataHash?: Blake2b256 | null
+    declare inlineDatum?: string | null
+    declare referenceScriptHash?: Blake2b256 | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'type';
+    declare static readonly keys: __.KeysOf<UTxODataSlice>;
+    declare static readonly elements: __.ElementsOf<UTxODataSlice>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class UTxODataSlice extends _UTxODataSliceAspect(__.Entity) {}
+Object.defineProperty(UTxODataSlice, 'name', { value: 'odatano.cardano.UTxODataSlice' })
+Object.defineProperty(UTxODataSlice, 'is_singular', { value: true })
+
+export function _NetworkInformationAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class NetworkInformation extends _._temporalAspect(Base) {
+    declare network?: __.Key<string>
+    declare maxSupply?: Lovelace | null
+    declare totalSupply?: Lovelace | null
+    declare circulatingSupply?: Lovelace | null
+    declare lockedSupply?: Lovelace | null
+    declare treasurySupply?: Lovelace | null
+    declare reservesSupply?: Lovelace | null
+    declare liveStake?: Lovelace | null
+    declare activeStake?: Lovelace | null
+    static override readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<NetworkInformation>;
+    declare static readonly elements: __.ElementsOf<NetworkInformation>;
+    declare static readonly actions: typeof _.temporal.actions & globalThis.Record<never, never>;
+  };
+}
+export class NetworkInformation extends _NetworkInformationAspect(__.Entity) {}
+Object.defineProperty(NetworkInformation, 'name', { value: 'odatano.cardano.NetworkInformation' })
+Object.defineProperty(NetworkInformation, 'is_singular', { value: true })
+export class NetworkInformation_ extends Array<NetworkInformation> {$count?: number}
+Object.defineProperty(NetworkInformation_, 'name', { value: 'odatano.cardano.NetworkInformation' })
+
+export function _BlockAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class Block extends Base {
+    declare hash?: __.Key<string>
+    declare time?: string | null
+    declare height?: number | null
+    declare slotLeader?: string | null
+    declare epochNumber?: number | null
+    declare epoch?: __.Association.to<Epoch> | null
+    declare epochSlot?: number | null
+    declare size?: number | null
+    declare txCount?: number | null
+    declare fees?: Lovelace | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<Block>;
+    declare static readonly elements: __.ElementsOf<Block>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class Block extends _BlockAspect(__.Entity) {}
+Object.defineProperty(Block, 'name', { value: 'odatano.cardano.Blocks' })
+Object.defineProperty(Block, 'is_singular', { value: true })
+export class Blocks extends Array<Block> {$count?: number}
+Object.defineProperty(Blocks, 'name', { value: 'odatano.cardano.Blocks' })
+
+export function _EpochAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class Epoch extends Base {
+    declare epoch?: __.Key<number>
+    declare startTime?: number | null
+    declare endTime?: number | null
+    declare firstBlockTime?: number | null
+    declare lastBlockTime?: number | null
+    declare blockCount?: number | null
+    declare txCount?: number | null
+    declare output?: string | null
+    declare fees?: Lovelace | null
+    declare activeStake?: Lovelace | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<Epoch>;
+    declare static readonly elements: __.ElementsOf<Epoch>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class Epoch extends _EpochAspect(__.Entity) {}
+Object.defineProperty(Epoch, 'name', { value: 'odatano.cardano.Epochs' })
+Object.defineProperty(Epoch, 'is_singular', { value: true })
+export class Epochs extends Array<Epoch> {$count?: number}
+Object.defineProperty(Epochs, 'name', { value: 'odatano.cardano.Epochs' })
+
+export function _PoolAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class Pool extends Base {
+    declare poolId?: __.Key<string>
+    declare vrfKeyHash?: string | null
+    declare blocksMinted?: number | null
+    declare blocksEpoch?: number | null
+    declare liveStake?: Lovelace | null
+    declare liveSize?: number | null
+    declare liveSaturation?: number | null
+    declare liveDelegators?: number | null
+    declare activeStake?: Lovelace | null
+    declare activeSize?: number | null
+    declare pledge?: Lovelace | null
+    declare margin?: number | null
+    declare fixedCost?: Lovelace | null
+    declare rewardAccount?: string | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<Pool>;
+    declare static readonly elements: __.ElementsOf<Pool>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class Pool extends _PoolAspect(__.Entity) {}
+Object.defineProperty(Pool, 'name', { value: 'odatano.cardano.Pools' })
+Object.defineProperty(Pool, 'is_singular', { value: true })
+export class Pools extends Array<Pool> {$count?: number}
+Object.defineProperty(Pools, 'name', { value: 'odatano.cardano.Pools' })
+
+export function _DrepAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class Drep extends Base {
+    declare drepId?: __.Key<string>
+    declare hex?: string | null
+    declare amount?: Lovelace | null
+    declare hasScript?: boolean | null
+    declare lastActiveEpoch?: number | null
+    declare retired?: boolean | null
+    declare expired?: boolean | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<Drep>;
+    declare static readonly elements: __.ElementsOf<Drep>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class Drep extends _DrepAspect(__.Entity) {}
+Object.defineProperty(Drep, 'name', { value: 'odatano.cardano.Dreps' })
+Object.defineProperty(Drep, 'is_singular', { value: true })
+export class Dreps extends Array<Drep> {$count?: number}
+Object.defineProperty(Dreps, 'name', { value: 'odatano.cardano.Dreps' })
+
+export function _AddressAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class Address extends _._temporalAspect(Base) {
+    declare address?: __.Key<Bech32>
+    declare stakeAddress?: Bech32 | null
+    declare type?: string | null
+    declare isScript?: boolean | null
+    declare totalLovelace?: Lovelace | null
+    declare transactions?: __.Composition.of.many<AddressTransactions>
+    declare assets?: __.Composition.of.many<AddressAssets>
+    declare utxos?: __.Composition.of.many<AddressUTxOs>
+    declare hasTransactions?: boolean | null
+    declare hasAssets?: boolean | null
+    declare hasUTxOs?: boolean | null
+    static override readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<Address>;
+    declare static readonly elements: __.ElementsOf<Address>;
+    declare static readonly actions: typeof _.temporal.actions & globalThis.Record<never, never>;
+  };
+}
+export class Address extends _AddressAspect(__.Entity) {}
+Object.defineProperty(Address, 'name', { value: 'odatano.cardano.Addresses' })
+Object.defineProperty(Address, 'is_singular', { value: true })
+export class Addresses extends Array<Address> {$count?: number}
+Object.defineProperty(Addresses, 'name', { value: 'odatano.cardano.Addresses' })
+
+export function _AddressAssetAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class AddressAsset extends _._temporalAspect(Base) {
+    declare address?: __.Key<__.Association.to<Address>>
+    declare address_address?: __.Key<Bech32>
+    declare unit?: __.Key<AssetUnit>
+    declare asset_quantity?: Lovelace | null
+    declare asset_policyId?: Blake2b224 | null
+    declare asset_assetNameHex?: string | null
+    declare asset_assetName?: string | null
+    declare asset_fingerprint?: string | null
+    static override readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<AddressAsset>;
+    declare static readonly elements: __.ElementsOf<AddressAsset>;
+    declare static readonly actions: typeof _.temporal.actions & globalThis.Record<never, never>;
+  };
+}
+export class AddressAsset extends _AddressAssetAspect(__.Entity) {}
+Object.defineProperty(AddressAsset, 'name', { value: 'odatano.cardano.AddressAssets' })
+Object.defineProperty(AddressAsset, 'is_singular', { value: true })
+export class AddressAssets extends Array<AddressAsset> {$count?: number}
+Object.defineProperty(AddressAssets, 'name', { value: 'odatano.cardano.AddressAssets' })
+
+export function _AddressUTxOAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class AddressUTxO extends _._temporalAspect(Base) {
+    declare address?: __.Key<__.Association.to<Address>>
+    declare address_address?: __.Key<Bech32>
+    declare hash?: __.Key<Blake2b256>
+    declare index?: __.Key<number>
+    declare blockHash?: Blake2b256 | null
+    declare utxodata_dataHash?: Blake2b256 | null
+    declare utxodata_inlineDatum?: string | null
+    declare utxodata_referenceScriptHash?: Blake2b256 | null
+    declare lovelace?: Lovelace | null
+    declare assets?: __.Composition.of.many<UTxOAssets>
+    declare hasAssets?: boolean | null
+    static override readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<AddressUTxO>;
+    declare static readonly elements: __.ElementsOf<AddressUTxO>;
+    declare static readonly actions: typeof _.temporal.actions & globalThis.Record<never, never>;
+  };
+}
+export class AddressUTxO extends _AddressUTxOAspect(__.Entity) {}
+Object.defineProperty(AddressUTxO, 'name', { value: 'odatano.cardano.AddressUTxOs' })
+Object.defineProperty(AddressUTxO, 'is_singular', { value: true })
+export class AddressUTxOs extends Array<AddressUTxO> {$count?: number}
+Object.defineProperty(AddressUTxOs, 'name', { value: 'odatano.cardano.AddressUTxOs' })
+
+export function _UTxOAssetAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class UTxOAsset extends _._temporalAspect(Base) {
+    declare utxo?: __.Key<__.Association.to<AddressUTxO>>
+    declare utxo_hash?: __.Key<Blake2b256>
+    declare utxo_index?: __.Key<number>
+    declare utxo_address_address?: __.Key<Bech32>
+    declare unit?: __.Key<AssetUnit>
+    declare asset_quantity?: Lovelace | null
+    declare asset_policyId?: Blake2b224 | null
+    declare asset_assetNameHex?: string | null
+    declare asset_assetName?: string | null
+    declare asset_fingerprint?: string | null
+    static override readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<UTxOAsset>;
+    declare static readonly elements: __.ElementsOf<UTxOAsset>;
+    declare static readonly actions: typeof _.temporal.actions & globalThis.Record<never, never>;
+  };
+}
+export class UTxOAsset extends _UTxOAssetAspect(__.Entity) {}
+Object.defineProperty(UTxOAsset, 'name', { value: 'odatano.cardano.UTxOAssets' })
+Object.defineProperty(UTxOAsset, 'is_singular', { value: true })
+export class UTxOAssets extends Array<UTxOAsset> {$count?: number}
+Object.defineProperty(UTxOAssets, 'name', { value: 'odatano.cardano.UTxOAssets' })
+
+export function _AccountAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class Account extends _._temporalAspect(Base) {
+    declare stakeAddress?: __.Key<string>
+    declare active?: boolean | null
+    declare activeEpoch?: number | null
+    declare controlledAmount?: Lovelace | null
+    declare rewardsSum?: Lovelace | null
+    declare withdrawalsSum?: Lovelace | null
+    declare reservesSum?: Lovelace | null
+    declare treasurySum?: Lovelace | null
+    declare withdrawableAmount?: Lovelace | null
+    declare poolId?: __.Association.to<Pool> | null
+    declare poolId_poolId?: string | null
+    declare drepId?: __.Association.to<Drep> | null
+    declare drepId_drepId?: string | null
+    declare Address?: __.Composition.of.many<Addresses>
+    declare hasAddresses?: boolean | null
+    static override readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<Account>;
+    declare static readonly elements: __.ElementsOf<Account>;
+    declare static readonly actions: typeof _.temporal.actions & globalThis.Record<never, never>;
+  };
+}
+export class Account extends _AccountAspect(__.Entity) {}
+Object.defineProperty(Account, 'name', { value: 'odatano.cardano.Accounts' })
+Object.defineProperty(Account, 'is_singular', { value: true })
+export class Accounts extends Array<Account> {$count?: number}
+Object.defineProperty(Accounts, 'name', { value: 'odatano.cardano.Accounts' })
+
+export function _TransactionAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class Transaction extends Base {
+    declare hash?: __.Key<Blake2b256>
+    declare blockHash?: Blake2b256 | null
+    declare blockHeight?: number | null
+    declare blockTime?: number | null
+    declare slot?: number | null
+    declare txIndex?: number | null
+    declare fee?: Lovelace | null
+    declare deposit?: Lovelace | null
+    declare size?: number | null
+    declare metadata?: __.Composition.of.many<TransactionMetadata_>
+    declare inputs?: __.Composition.of.many<TransactionInputs>
+    declare outputs?: __.Composition.of.many<TransactionOutputs>
+    declare hasMetadata?: boolean | null
+    declare hasInputs?: boolean | null
+    declare hasOutputs?: boolean | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<Transaction>;
+    declare static readonly elements: __.ElementsOf<Transaction>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class Transaction extends _TransactionAspect(__.Entity) {}
+Object.defineProperty(Transaction, 'name', { value: 'odatano.cardano.Transactions' })
+Object.defineProperty(Transaction, 'is_singular', { value: true })
+export class Transactions extends Array<Transaction> {$count?: number}
+Object.defineProperty(Transactions, 'name', { value: 'odatano.cardano.Transactions' })
+
+export function _TransactionInputAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class TransactionInput extends Base {
+    declare tx?: __.Key<__.Association.to<Transaction>>
+    declare tx_hash?: __.Key<Blake2b256>
+    declare inputIndex?: __.Key<number>
+    declare address?: __.Association.to<Address> | null
+    declare address_address?: Bech32 | null
+    declare utxoData_dataHash?: Blake2b256 | null
+    declare utxoData_inlineDatum?: string | null
+    declare utxoData_referenceScriptHash?: Blake2b256 | null
+    declare isCollateral?: boolean | null
+    declare isReference?: boolean | null
+    declare assets?: __.Composition.of.many<TransactionInputAssets>
+    declare hasAddresses?: boolean | null
+    declare hasAssets?: boolean | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<TransactionInput>;
+    declare static readonly elements: __.ElementsOf<TransactionInput>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class TransactionInput extends _TransactionInputAspect(__.Entity) {}
+Object.defineProperty(TransactionInput, 'name', { value: 'odatano.cardano.TransactionInputs' })
+Object.defineProperty(TransactionInput, 'is_singular', { value: true })
+export class TransactionInputs extends Array<TransactionInput> {$count?: number}
+Object.defineProperty(TransactionInputs, 'name', { value: 'odatano.cardano.TransactionInputs' })
+
+export function _TransactionInputAssetAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class TransactionInputAsset extends Base {
+    declare input?: __.Key<__.Association.to<TransactionInput>>
+    declare input_inputIndex?: __.Key<number>
+    declare input_tx_hash?: __.Key<Blake2b256>
+    declare unit?: __.Key<AssetUnit>
+    declare asset_quantity?: Lovelace | null
+    declare asset_policyId?: Blake2b224 | null
+    declare asset_assetNameHex?: string | null
+    declare asset_assetName?: string | null
+    declare asset_fingerprint?: string | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<TransactionInputAsset>;
+    declare static readonly elements: __.ElementsOf<TransactionInputAsset>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class TransactionInputAsset extends _TransactionInputAssetAspect(__.Entity) {}
+Object.defineProperty(TransactionInputAsset, 'name', { value: 'odatano.cardano.TransactionInputAssets' })
+Object.defineProperty(TransactionInputAsset, 'is_singular', { value: true })
+export class TransactionInputAssets extends Array<TransactionInputAsset> {$count?: number}
+Object.defineProperty(TransactionInputAssets, 'name', { value: 'odatano.cardano.TransactionInputAssets' })
+
+export function _TransactionOutputAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class TransactionOutput extends Base {
+    declare tx?: __.Key<__.Association.to<Transaction>>
+    declare tx_hash?: __.Key<Blake2b256>
+    declare outputIndex?: __.Key<number>
+    declare address?: __.Association.to<Address> | null
+    declare address_address?: Bech32 | null
+    declare utxo_dataHash?: Blake2b256 | null
+    declare utxo_inlineDatum?: string | null
+    declare utxo_referenceScriptHash?: Blake2b256 | null
+    declare assets?: __.Composition.of.many<TransactionOutputAssets>
+    declare hasAddresses?: boolean | null
+    declare hasAssets?: boolean | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<TransactionOutput>;
+    declare static readonly elements: __.ElementsOf<TransactionOutput>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class TransactionOutput extends _TransactionOutputAspect(__.Entity) {}
+Object.defineProperty(TransactionOutput, 'name', { value: 'odatano.cardano.TransactionOutputs' })
+Object.defineProperty(TransactionOutput, 'is_singular', { value: true })
+export class TransactionOutputs extends Array<TransactionOutput> {$count?: number}
+Object.defineProperty(TransactionOutputs, 'name', { value: 'odatano.cardano.TransactionOutputs' })
+
+export function _TransactionOutputAssetAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class TransactionOutputAsset extends Base {
+    declare output?: __.Key<__.Association.to<TransactionOutput>>
+    declare output_outputIndex?: __.Key<number>
+    declare output_tx_hash?: __.Key<Blake2b256>
+    declare unit?: __.Key<AssetUnit>
+    declare asset_quantity?: Lovelace | null
+    declare asset_policyId?: Blake2b224 | null
+    declare asset_assetNameHex?: string | null
+    declare asset_assetName?: string | null
+    declare asset_fingerprint?: string | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<TransactionOutputAsset>;
+    declare static readonly elements: __.ElementsOf<TransactionOutputAsset>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class TransactionOutputAsset extends _TransactionOutputAssetAspect(__.Entity) {}
+Object.defineProperty(TransactionOutputAsset, 'name', { value: 'odatano.cardano.TransactionOutputAssets' })
+Object.defineProperty(TransactionOutputAsset, 'is_singular', { value: true })
+export class TransactionOutputAssets extends Array<TransactionOutputAsset> {$count?: number}
+Object.defineProperty(TransactionOutputAssets, 'name', { value: 'odatano.cardano.TransactionOutputAssets' })
+
+export function _TransactionMetadataAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class TransactionMetadata extends Base {
+    declare id?: __.Key<number>
+    declare tx?: __.Key<__.Association.to<Transaction>>
+    declare tx_hash?: __.Key<Blake2b256>
+    declare label?: string | null
+    declare payload?: string | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<TransactionMetadata>;
+    declare static readonly elements: __.ElementsOf<TransactionMetadata>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class TransactionMetadata extends _TransactionMetadataAspect(__.Entity) {}
+Object.defineProperty(TransactionMetadata, 'name', { value: 'odatano.cardano.TransactionMetadata' })
+Object.defineProperty(TransactionMetadata, 'is_singular', { value: true })
+export class TransactionMetadata_ extends Array<TransactionMetadata> {$count?: number}
+Object.defineProperty(TransactionMetadata_, 'name', { value: 'odatano.cardano.TransactionMetadata' })
+
+export function _LedgerProtocolParameterAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class LedgerProtocolParameter extends Base {
+    declare network?: __.Key<string>
+    declare epoch?: __.Key<number>
+    declare minFeeA?: number | null
+    declare minFeeB?: number | null
+    declare maxBlockSize?: number | null
+    declare maxTxSize?: number | null
+    declare maxBlockHeaderSize?: number | null
+    declare keyDeposit?: string | null
+    declare poolDeposit?: string | null
+    declare eMax?: number | null
+    declare nOpt?: number | null
+    declare a0?: number | null
+    declare rho?: number | null
+    declare tau?: number | null
+    declare minPoolCost?: string | null
+    declare decentralisationParam?: number | null
+    declare extraEntropy?: string | null
+    declare protocolMajorVer?: number | null
+    declare protocolMinorVer?: number | null
+    declare minUtxo?: string | null
+    declare nonce?: string | null
+    declare costModels?: string | null
+    declare priceMem?: number | null
+    declare priceStep?: number | null
+    declare maxTxExMem?: string | null
+    declare maxTxExSteps?: string | null
+    declare maxBlockExMem?: string | null
+    declare maxBlockExSteps?: string | null
+    declare maxValSize?: string | null
+    declare collateralPercent?: number | null
+    declare maxCollateralInputs?: number | null
+    declare coinsPerUtxoSize?: string | null
+    declare coinsPerUtxoWord?: string | null
+    declare fetchedAt?: __.CdsTimestamp | null
+    declare source?: string | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<LedgerProtocolParameter>;
+    declare static readonly elements: __.ElementsOf<LedgerProtocolParameter>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class LedgerProtocolParameter extends _LedgerProtocolParameterAspect(__.Entity) {}
+Object.defineProperty(LedgerProtocolParameter, 'name', { value: 'odatano.cardano.LedgerProtocolParameters' })
+Object.defineProperty(LedgerProtocolParameter, 'is_singular', { value: true })
+export class LedgerProtocolParameters extends Array<LedgerProtocolParameter> {$count?: number}
+Object.defineProperty(LedgerProtocolParameters, 'name', { value: 'odatano.cardano.LedgerProtocolParameters' })
+
+export function _TransactionBuildAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class TransactionBuild extends _._temporalAspect(Base) {
+    declare id?: __.Key<string>
+    declare network?: string | null
+    declare builderEngine?: string | null
+    declare senderAddress?: Bech32 | null
+    declare changeAddress?: Bech32 | null
+    declare unsignedTxCbor?: string | null
+    declare txBodyHash?: Blake2b256 | null
+    declare fee?: Lovelace | null
+    declare size?: number | null
+    declare createdAt?: number | null
+    declare inputs?: __.Composition.of.many<TransactionBuildInputs>
+    declare outputs?: __.Composition.of.many<TransactionBuildOutputs>
+    declare submission?: __.Association.to<TransactionSubmission> | null
+    declare hasInputs?: boolean | null
+    declare hasOutputs?: boolean | null
+    declare wasSubmitted?: boolean | null
+    static override readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<TransactionBuild>;
+    declare static readonly elements: __.ElementsOf<TransactionBuild>;
+    declare static readonly actions: typeof _.temporal.actions & globalThis.Record<never, never>;
+  };
+}
+export class TransactionBuild extends _TransactionBuildAspect(__.Entity) {}
+Object.defineProperty(TransactionBuild, 'name', { value: 'odatano.cardano.TransactionBuilds' })
+Object.defineProperty(TransactionBuild, 'is_singular', { value: true })
+export class TransactionBuilds extends Array<TransactionBuild> {$count?: number}
+Object.defineProperty(TransactionBuilds, 'name', { value: 'odatano.cardano.TransactionBuilds' })
+
+export function _TransactionBuildInputAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class TransactionBuildInput extends Base {
+    declare build?: __.Key<__.Association.to<TransactionBuild>>
+    declare build_id?: __.Key<string>
+    declare inputIndex?: __.Key<number>
+    declare txHash?: Blake2b256 | null
+    declare outputIndex?: number | null
+    declare address?: Bech32 | null
+    declare lovelace?: Lovelace | null
+    declare assets?: __.Composition.of.many<TransactionBuildInputAssets>
+    declare hasAssets?: boolean | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<TransactionBuildInput>;
+    declare static readonly elements: __.ElementsOf<TransactionBuildInput>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class TransactionBuildInput extends _TransactionBuildInputAspect(__.Entity) {}
+Object.defineProperty(TransactionBuildInput, 'name', { value: 'odatano.cardano.TransactionBuildInputs' })
+Object.defineProperty(TransactionBuildInput, 'is_singular', { value: true })
+export class TransactionBuildInputs extends Array<TransactionBuildInput> {$count?: number}
+Object.defineProperty(TransactionBuildInputs, 'name', { value: 'odatano.cardano.TransactionBuildInputs' })
+
+export function _TransactionBuildInputAssetAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class TransactionBuildInputAsset extends Base {
+    declare input?: __.Key<__.Association.to<TransactionBuildInput>>
+    declare input_inputIndex?: __.Key<number>
+    declare input_build_id?: __.Key<string>
+    declare unit?: __.Key<AssetUnit>
+    declare asset_quantity?: Lovelace | null
+    declare asset_policyId?: Blake2b224 | null
+    declare asset_assetNameHex?: string | null
+    declare asset_assetName?: string | null
+    declare asset_fingerprint?: string | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<TransactionBuildInputAsset>;
+    declare static readonly elements: __.ElementsOf<TransactionBuildInputAsset>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class TransactionBuildInputAsset extends _TransactionBuildInputAssetAspect(__.Entity) {}
+Object.defineProperty(TransactionBuildInputAsset, 'name', { value: 'odatano.cardano.TransactionBuildInputAssets' })
+Object.defineProperty(TransactionBuildInputAsset, 'is_singular', { value: true })
+export class TransactionBuildInputAssets extends Array<TransactionBuildInputAsset> {$count?: number}
+Object.defineProperty(TransactionBuildInputAssets, 'name', { value: 'odatano.cardano.TransactionBuildInputAssets' })
+
+export function _TransactionBuildOutputAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class TransactionBuildOutput extends Base {
+    declare build?: __.Key<__.Association.to<TransactionBuild>>
+    declare build_id?: __.Key<string>
+    declare outputIndex?: __.Key<number>
+    declare address?: Bech32 | null
+    declare lovelace?: Lovelace | null
+    declare isChange?: boolean | null
+    declare assets?: __.Composition.of.many<TransactionBuildOutputAssets>
+    declare hasAssets?: boolean | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<TransactionBuildOutput>;
+    declare static readonly elements: __.ElementsOf<TransactionBuildOutput>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class TransactionBuildOutput extends _TransactionBuildOutputAspect(__.Entity) {}
+Object.defineProperty(TransactionBuildOutput, 'name', { value: 'odatano.cardano.TransactionBuildOutputs' })
+Object.defineProperty(TransactionBuildOutput, 'is_singular', { value: true })
+export class TransactionBuildOutputs extends Array<TransactionBuildOutput> {$count?: number}
+Object.defineProperty(TransactionBuildOutputs, 'name', { value: 'odatano.cardano.TransactionBuildOutputs' })
+
+export function _TransactionBuildOutputAssetAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class TransactionBuildOutputAsset extends Base {
+    declare output?: __.Key<__.Association.to<TransactionBuildOutput>>
+    declare output_outputIndex?: __.Key<number>
+    declare output_build_id?: __.Key<string>
+    declare unit?: __.Key<AssetUnit>
+    declare asset_quantity?: Lovelace | null
+    declare asset_policyId?: Blake2b224 | null
+    declare asset_assetNameHex?: string | null
+    declare asset_assetName?: string | null
+    declare asset_fingerprint?: string | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<TransactionBuildOutputAsset>;
+    declare static readonly elements: __.ElementsOf<TransactionBuildOutputAsset>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class TransactionBuildOutputAsset extends _TransactionBuildOutputAssetAspect(__.Entity) {}
+Object.defineProperty(TransactionBuildOutputAsset, 'name', { value: 'odatano.cardano.TransactionBuildOutputAssets' })
+Object.defineProperty(TransactionBuildOutputAsset, 'is_singular', { value: true })
+export class TransactionBuildOutputAssets extends Array<TransactionBuildOutputAsset> {$count?: number}
+Object.defineProperty(TransactionBuildOutputAssets, 'name', { value: 'odatano.cardano.TransactionBuildOutputAssets' })
+
+export function _TransactionSubmissionAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class TransactionSubmission extends Base {
+    declare id?: __.Key<string>
+    declare build?: __.Association.to<TransactionBuild> | null
+    declare build_id?: string | null
+    declare signedTxCbor?: string | null
+    declare txHash?: Blake2b256 | null
+    declare submittedAt?: number | null
+    declare status?: SubmissionStatus | null
+    declare errorCode?: string | null
+    declare errorMessage?: string | null
+    declare retryCount?: number | null
+    declare errors?: __.Composition.of.many<TransactionSubmissionErrors>
+    declare hasErrors?: boolean | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<TransactionSubmission>;
+    declare static readonly elements: __.ElementsOf<TransactionSubmission>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class TransactionSubmission extends _TransactionSubmissionAspect(__.Entity) {}
+Object.defineProperty(TransactionSubmission, 'name', { value: 'odatano.cardano.TransactionSubmissions' })
+Object.defineProperty(TransactionSubmission, 'is_singular', { value: true })
+export class TransactionSubmissions extends Array<TransactionSubmission> {$count?: number}
+Object.defineProperty(TransactionSubmissions, 'name', { value: 'odatano.cardano.TransactionSubmissions' })
+
+export function _TransactionSubmissionErrorAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class TransactionSubmissionError extends Base {
+    declare id?: __.Key<string>
+    declare submission?: __.Association.to<TransactionSubmission> | null
+    declare submission_id?: string | null
+    declare occurredAt?: number | null
+    declare errorType?: string | null
+    declare errorCode?: string | null
+    declare errorMessage?: string | null
+    declare errorDetails?: string | null
+    declare isRecoverable?: boolean | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<TransactionSubmissionError>;
+    declare static readonly elements: __.ElementsOf<TransactionSubmissionError>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class TransactionSubmissionError extends _TransactionSubmissionErrorAspect(__.Entity) {}
+Object.defineProperty(TransactionSubmissionError, 'name', { value: 'odatano.cardano.TransactionSubmissionErrors' })
+Object.defineProperty(TransactionSubmissionError, 'is_singular', { value: true })
+export class TransactionSubmissionErrors extends Array<TransactionSubmissionError> {$count?: number}
+Object.defineProperty(TransactionSubmissionErrors, 'name', { value: 'odatano.cardano.TransactionSubmissionErrors' })
+
+export function _AddressTransactionAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class AddressTransaction extends Base {
+    declare address?: __.Key<__.Association.to<Address>>
+    declare address_address?: __.Key<Bech32>
+    declare tx?: __.Key<__.Association.to<Transaction>>
+    declare tx_hash?: __.Key<Blake2b256>
+    declare netAmount?: number | null
+    declare blockTime?: number | null
+    declare netAssets?: string | null
+    declare hasAssets?: boolean | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<AddressTransaction>;
+    declare static readonly elements: __.ElementsOf<AddressTransaction>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class AddressTransaction extends _AddressTransactionAspect(__.Entity) {}
+Object.defineProperty(AddressTransaction, 'name', { value: 'odatano.cardano.AddressTransactions' })
+Object.defineProperty(AddressTransaction, 'is_singular', { value: true })
+export class AddressTransactions extends Array<AddressTransaction> {$count?: number}
+Object.defineProperty(AddressTransactions, 'name', { value: 'odatano.cardano.AddressTransactions' })
+
+export function _AddressSigningRequestAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class AddressSigningRequest extends Base {
+    declare address?: __.Key<__.Association.to<Address>>
+    declare address_address?: __.Key<Bech32>
+    declare signingRequest?: __.Key<__.Association.to<SigningRequest>>
+    declare signingRequest_id?: __.Key<string>
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<AddressSigningRequest>;
+    declare static readonly elements: __.ElementsOf<AddressSigningRequest>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class AddressSigningRequest extends _AddressSigningRequestAspect(__.Entity) {}
+Object.defineProperty(AddressSigningRequest, 'name', { value: 'odatano.cardano.AddressSigningRequests' })
+Object.defineProperty(AddressSigningRequest, 'is_singular', { value: true })
+export class AddressSigningRequests extends Array<AddressSigningRequest> {$count?: number}
+Object.defineProperty(AddressSigningRequests, 'name', { value: 'odatano.cardano.AddressSigningRequests' })
+
+export function _AddressTransactionBuildAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class AddressTransactionBuild extends Base {
+    declare address?: __.Key<__.Association.to<Address>>
+    declare address_address?: __.Key<Bech32>
+    declare txBuild?: __.Key<__.Association.to<TransactionBuild>>
+    declare txBuild_id?: __.Key<string>
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<AddressTransactionBuild>;
+    declare static readonly elements: __.ElementsOf<AddressTransactionBuild>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class AddressTransactionBuild extends _AddressTransactionBuildAspect(__.Entity) {}
+Object.defineProperty(AddressTransactionBuild, 'name', { value: 'odatano.cardano.AddressTransactionBuilds' })
+Object.defineProperty(AddressTransactionBuild, 'is_singular', { value: true })
+export class AddressTransactionBuilds extends Array<AddressTransactionBuild> {$count?: number}
+Object.defineProperty(AddressTransactionBuilds, 'name', { value: 'odatano.cardano.AddressTransactionBuilds' })
+
+export function _SigningRequestAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class SigningRequest extends Base {
+    declare id?: __.Key<string>
+    declare build?: __.Association.to<TransactionBuild> | null
+    declare build_id?: string | null
+    declare txBodyHash?: Blake2b256 | null
+    declare unsignedTxCbor?: string | null
+    declare network?: string | null
+    declare status?: SigningStatus | null
+    declare createdAt?: __.CdsTimestamp | null
+    declare expiresAt?: __.CdsTimestamp | null
+    declare signedAt?: __.CdsTimestamp | null
+    declare submittedAt?: __.CdsTimestamp | null
+    declare cardanoCliCommand?: string | null
+    declare cip30TxCbor?: string | null
+    declare signerType?: string | null
+    declare signerInfo?: string | null
+    declare verifications?: __.Composition.of.many<SignatureVerifications>
+    declare submission?: __.Association.to<TransactionSubmission> | null
+    declare submission_id?: string | null
+    declare errorMessage?: string | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<SigningRequest>;
+    declare static readonly elements: __.ElementsOf<SigningRequest>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class SigningRequest extends _SigningRequestAspect(__.Entity) {}
+Object.defineProperty(SigningRequest, 'name', { value: 'odatano.cardano.SigningRequests' })
+Object.defineProperty(SigningRequest, 'is_singular', { value: true })
+export class SigningRequests extends Array<SigningRequest> {$count?: number}
+Object.defineProperty(SigningRequests, 'name', { value: 'odatano.cardano.SigningRequests' })
+
+export function _SignatureVerificationAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class SignatureVerification extends Base {
+    declare id?: __.Key<string>
+    declare signingRequest?: __.Association.to<SigningRequest> | null
+    declare signingRequest_id?: string | null
+    declare signedTxCbor?: string | null
+    declare isValid?: boolean | null
+    declare txBodyHash?: Blake2b256 | null
+    declare witnessCount?: number | null
+    declare signerKeyHashes?: string | null
+    declare errorMessage?: string | null
+    declare warnings?: string | null
+    declare verifiedAt?: __.CdsTimestamp | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<SignatureVerification>;
+    declare static readonly elements: __.ElementsOf<SignatureVerification>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class SignatureVerification extends _SignatureVerificationAspect(__.Entity) {}
+Object.defineProperty(SignatureVerification, 'name', { value: 'odatano.cardano.SignatureVerifications' })
+Object.defineProperty(SignatureVerification, 'is_singular', { value: true })
+export class SignatureVerifications extends Array<SignatureVerification> {$count?: number}
+Object.defineProperty(SignatureVerifications, 'name', { value: 'odatano.cardano.SignatureVerifications' })