@odatano/core 0.3.2 → 0.3.3

package/@cds-models/CardanoODataService/index.ts

@@ -0,0 +1,646 @@
+// This is an automatically generated file. Please do not change its contents manually!
+import * as _odatano_cardano from './../odatano/cardano';
+import * as __ from './../_';
+
+export default class {
+  declare static readonly GetNetworkInformation: typeof GetNetworkInformation;
+  declare static readonly GetBlockByHash: typeof GetBlockByHash;
+  declare static readonly GetEpochByNumber: typeof GetEpochByNumber;
+  declare static readonly GetPoolById: typeof GetPoolById;
+  declare static readonly GetDrepById: typeof GetDrepById;
+  declare static readonly GetAccountByStakeAddress: typeof GetAccountByStakeAddress;
+  declare static readonly GetTransactionByHash: typeof GetTransactionByHash;
+  declare static readonly GetMetadataByTxHash: typeof GetMetadataByTxHash;
+  declare static readonly GetAddressByBech32: typeof GetAddressByBech32;
+  declare static readonly GetUTxOsByAddress: typeof GetUTxOsByAddress;
+  declare static readonly GetAssetsByAddress: typeof GetAssetsByAddress;
+  declare static readonly GetLatestTransactionsByAddress: typeof GetLatestTransactionsByAddress;
+  declare static readonly GetLatestBlock: typeof GetLatestBlock;
+  declare static readonly GetLatestEpoch: typeof GetLatestEpoch;
+  declare static readonly GetLedgerProtocolParameters: typeof GetLedgerProtocolParameters;
+}
+
+export function _NetworkInformationAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class NetworkInformation extends Base {
+    declare validFrom?: __.CdsTimestamp | null
+    declare validTo?: __.CdsTimestamp | null
+    declare network?: __.Key<string>
+    declare maxSupply?: _odatano_cardano.Lovelace | null
+    declare totalSupply?: _odatano_cardano.Lovelace | null
+    declare circulatingSupply?: _odatano_cardano.Lovelace | null
+    declare lockedSupply?: _odatano_cardano.Lovelace | null
+    declare treasurySupply?: _odatano_cardano.Lovelace | null
+    declare reservesSupply?: _odatano_cardano.Lovelace | null
+    declare liveStake?: _odatano_cardano.Lovelace | null
+    declare activeStake?: _odatano_cardano.Lovelace | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<NetworkInformation>;
+    declare static readonly elements: __.ElementsOf<NetworkInformation>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class NetworkInformation extends _NetworkInformationAspect(__.Entity) {}
+Object.defineProperty(NetworkInformation, 'name', { value: 'CardanoODataService.NetworkInformation' })
+Object.defineProperty(NetworkInformation, 'is_singular', { value: true })
+export class NetworkInformation_ extends Array<NetworkInformation> {$count?: number}
+Object.defineProperty(NetworkInformation_, 'name', { value: 'CardanoODataService.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?: _odatano_cardano.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: 'CardanoODataService.Blocks' })
+Object.defineProperty(Block, 'is_singular', { value: true })
+export class Blocks extends Array<Block> {$count?: number}
+Object.defineProperty(Blocks, 'name', { value: 'CardanoODataService.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?: _odatano_cardano.Lovelace | null
+    declare activeStake?: _odatano_cardano.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: 'CardanoODataService.Epochs' })
+Object.defineProperty(Epoch, 'is_singular', { value: true })
+export class Epochs extends Array<Epoch> {$count?: number}
+Object.defineProperty(Epochs, 'name', { value: 'CardanoODataService.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?: _odatano_cardano.Lovelace | null
+    declare liveSize?: number | null
+    declare liveSaturation?: number | null
+    declare liveDelegators?: number | null
+    declare activeStake?: _odatano_cardano.Lovelace | null
+    declare activeSize?: number | null
+    declare pledge?: _odatano_cardano.Lovelace | null
+    declare margin?: number | null
+    declare fixedCost?: _odatano_cardano.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: 'CardanoODataService.Pools' })
+Object.defineProperty(Pool, 'is_singular', { value: true })
+export class Pools extends Array<Pool> {$count?: number}
+Object.defineProperty(Pools, 'name', { value: 'CardanoODataService.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?: _odatano_cardano.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: 'CardanoODataService.Dreps' })
+Object.defineProperty(Drep, 'is_singular', { value: true })
+export class Dreps extends Array<Drep> {$count?: number}
+Object.defineProperty(Dreps, 'name', { value: 'CardanoODataService.Dreps' })
+
+export function _TransactionAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class Transaction extends Base {
+    declare hash?: __.Key<_odatano_cardano.Blake2b256>
+    declare blockHash?: _odatano_cardano.Blake2b256 | null
+    declare blockHeight?: number | null
+    declare blockTime?: number | null
+    declare slot?: number | null
+    declare txIndex?: number | null
+    declare fee?: _odatano_cardano.Lovelace | null
+    declare deposit?: _odatano_cardano.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: 'CardanoODataService.Transactions' })
+Object.defineProperty(Transaction, 'is_singular', { value: true })
+export class Transactions extends Array<Transaction> {$count?: number}
+Object.defineProperty(Transactions, 'name', { value: 'CardanoODataService.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<_odatano_cardano.Blake2b256>
+    declare inputIndex?: __.Key<number>
+    declare address?: __.Association.to<Address> | null
+    declare address_address?: _odatano_cardano.Bech32 | null
+    declare utxoData_dataHash?: _odatano_cardano.Blake2b256 | null
+    declare utxoData_inlineDatum?: string | null
+    declare utxoData_referenceScriptHash?: _odatano_cardano.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: 'CardanoODataService.TransactionInputs' })
+Object.defineProperty(TransactionInput, 'is_singular', { value: true })
+export class TransactionInputs extends Array<TransactionInput> {$count?: number}
+Object.defineProperty(TransactionInputs, 'name', { value: 'CardanoODataService.TransactionInputs' })
+
+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<_odatano_cardano.Blake2b256>
+    declare outputIndex?: __.Key<number>
+    declare address?: __.Association.to<Address> | null
+    declare address_address?: _odatano_cardano.Bech32 | null
+    declare utxo_dataHash?: _odatano_cardano.Blake2b256 | null
+    declare utxo_inlineDatum?: string | null
+    declare utxo_referenceScriptHash?: _odatano_cardano.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: 'CardanoODataService.TransactionOutputs' })
+Object.defineProperty(TransactionOutput, 'is_singular', { value: true })
+export class TransactionOutputs extends Array<TransactionOutput> {$count?: number}
+Object.defineProperty(TransactionOutputs, 'name', { value: 'CardanoODataService.TransactionOutputs' })
+
+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<_odatano_cardano.Blake2b256>
+    declare unit?: __.Key<_odatano_cardano.AssetUnit>
+    declare asset_quantity?: _odatano_cardano.Lovelace | null
+    declare asset_policyId?: _odatano_cardano.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: 'CardanoODataService.TransactionInputAssets' })
+Object.defineProperty(TransactionInputAsset, 'is_singular', { value: true })
+export class TransactionInputAssets extends Array<TransactionInputAsset> {$count?: number}
+Object.defineProperty(TransactionInputAssets, 'name', { value: 'CardanoODataService.TransactionInputAssets' })
+
+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<_odatano_cardano.Blake2b256>
+    declare unit?: __.Key<_odatano_cardano.AssetUnit>
+    declare asset_quantity?: _odatano_cardano.Lovelace | null
+    declare asset_policyId?: _odatano_cardano.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: 'CardanoODataService.TransactionOutputAssets' })
+Object.defineProperty(TransactionOutputAsset, 'is_singular', { value: true })
+export class TransactionOutputAssets extends Array<TransactionOutputAsset> {$count?: number}
+Object.defineProperty(TransactionOutputAssets, 'name', { value: 'CardanoODataService.TransactionOutputAssets' })
+
+export function _AccountAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class Account extends Base {
+    declare validFrom?: __.CdsTimestamp | null
+    declare validTo?: __.CdsTimestamp | null
+    declare stakeAddress?: __.Key<string>
+    declare active?: boolean | null
+    declare activeEpoch?: number | null
+    declare controlledAmount?: _odatano_cardano.Lovelace | null
+    declare rewardsSum?: _odatano_cardano.Lovelace | null
+    declare withdrawalsSum?: _odatano_cardano.Lovelace | null
+    declare reservesSum?: _odatano_cardano.Lovelace | null
+    declare treasurySum?: _odatano_cardano.Lovelace | null
+    declare withdrawableAmount?: _odatano_cardano.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 readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<Account>;
+    declare static readonly elements: __.ElementsOf<Account>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class Account extends _AccountAspect(__.Entity) {}
+Object.defineProperty(Account, 'name', { value: 'CardanoODataService.Accounts' })
+Object.defineProperty(Account, 'is_singular', { value: true })
+export class Accounts extends Array<Account> {$count?: number}
+Object.defineProperty(Accounts, 'name', { value: 'CardanoODataService.Accounts' })
+
+export function _AddressAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class Address extends Base {
+    declare validFrom?: __.CdsTimestamp | null
+    declare validTo?: __.CdsTimestamp | null
+    declare address?: __.Key<_odatano_cardano.Bech32>
+    declare stakeAddress?: _odatano_cardano.Bech32 | null
+    declare type?: string | null
+    declare isScript?: boolean | null
+    declare totalLovelace?: _odatano_cardano.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 readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<Address>;
+    declare static readonly elements: __.ElementsOf<Address>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class Address extends _AddressAspect(__.Entity) {}
+Object.defineProperty(Address, 'name', { value: 'CardanoODataService.Addresses' })
+Object.defineProperty(Address, 'is_singular', { value: true })
+export class Addresses extends Array<Address> {$count?: number}
+Object.defineProperty(Addresses, 'name', { value: 'CardanoODataService.Addresses' })
+
+export function _AddressAssetAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class AddressAsset extends Base {
+    declare validFrom?: __.CdsTimestamp | null
+    declare validTo?: __.CdsTimestamp | null
+    declare address?: __.Key<__.Association.to<Address>>
+    declare address_address?: __.Key<_odatano_cardano.Bech32>
+    declare unit?: __.Key<_odatano_cardano.AssetUnit>
+    declare asset_quantity?: _odatano_cardano.Lovelace | null
+    declare asset_policyId?: _odatano_cardano.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<AddressAsset>;
+    declare static readonly elements: __.ElementsOf<AddressAsset>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class AddressAsset extends _AddressAssetAspect(__.Entity) {}
+Object.defineProperty(AddressAsset, 'name', { value: 'CardanoODataService.AddressAssets' })
+Object.defineProperty(AddressAsset, 'is_singular', { value: true })
+export class AddressAssets extends Array<AddressAsset> {$count?: number}
+Object.defineProperty(AddressAssets, 'name', { value: 'CardanoODataService.AddressAssets' })
+
+export function _AddressUTxOAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class AddressUTxO extends Base {
+    declare validFrom?: __.CdsTimestamp | null
+    declare validTo?: __.CdsTimestamp | null
+    declare address?: __.Key<__.Association.to<Address>>
+    declare address_address?: __.Key<_odatano_cardano.Bech32>
+    declare hash?: __.Key<_odatano_cardano.Blake2b256>
+    declare index?: __.Key<number>
+    declare blockHash?: _odatano_cardano.Blake2b256 | null
+    declare utxodata_dataHash?: _odatano_cardano.Blake2b256 | null
+    declare utxodata_inlineDatum?: string | null
+    declare utxodata_referenceScriptHash?: _odatano_cardano.Blake2b256 | null
+    declare lovelace?: _odatano_cardano.Lovelace | null
+    declare assets?: __.Composition.of.many<UTxOAssets>
+    declare hasAssets?: boolean | null
+    static readonly kind: 'entity' | 'type' | 'aspect' = 'entity';
+    declare static readonly keys: __.KeysOf<AddressUTxO>;
+    declare static readonly elements: __.ElementsOf<AddressUTxO>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class AddressUTxO extends _AddressUTxOAspect(__.Entity) {}
+Object.defineProperty(AddressUTxO, 'name', { value: 'CardanoODataService.AddressUTxOs' })
+Object.defineProperty(AddressUTxO, 'is_singular', { value: true })
+export class AddressUTxOs extends Array<AddressUTxO> {$count?: number}
+Object.defineProperty(AddressUTxOs, 'name', { value: 'CardanoODataService.AddressUTxOs' })
+
+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<_odatano_cardano.Bech32>
+    declare tx?: __.Key<__.Association.to<Transaction>>
+    declare tx_hash?: __.Key<_odatano_cardano.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: 'CardanoODataService.AddressTransactions' })
+Object.defineProperty(AddressTransaction, 'is_singular', { value: true })
+export class AddressTransactions extends Array<AddressTransaction> {$count?: number}
+Object.defineProperty(AddressTransactions, 'name', { value: 'CardanoODataService.AddressTransactions' })
+
+export function _UTxOAssetAspect<TBase extends new (...args: any[]) => object>(Base: TBase) {
+  return class UTxOAsset extends Base {
+    declare validFrom?: __.CdsTimestamp | null
+    declare validTo?: __.CdsTimestamp | null
+    declare utxo?: __.Key<__.Association.to<AddressUTxO>>
+    declare utxo_hash?: __.Key<_odatano_cardano.Blake2b256>
+    declare utxo_index?: __.Key<number>
+    declare utxo_address_address?: __.Key<_odatano_cardano.Bech32>
+    declare unit?: __.Key<_odatano_cardano.AssetUnit>
+    declare asset_quantity?: _odatano_cardano.Lovelace | null
+    declare asset_policyId?: _odatano_cardano.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<UTxOAsset>;
+    declare static readonly elements: __.ElementsOf<UTxOAsset>;
+    declare static readonly actions: globalThis.Record<never, never>;
+  };
+}
+export class UTxOAsset extends _UTxOAssetAspect(__.Entity) {}
+Object.defineProperty(UTxOAsset, 'name', { value: 'CardanoODataService.UTxOAssets' })
+Object.defineProperty(UTxOAsset, 'is_singular', { value: true })
+export class UTxOAssets extends Array<UTxOAsset> {$count?: number}
+Object.defineProperty(UTxOAssets, 'name', { value: 'CardanoODataService.UTxOAssets' })
+
+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<_odatano_cardano.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: 'CardanoODataService.TransactionMetadata' })
+Object.defineProperty(TransactionMetadata, 'is_singular', { value: true })
+export class TransactionMetadata_ extends Array<TransactionMetadata> {$count?: number}
+Object.defineProperty(TransactionMetadata_, 'name', { value: 'CardanoODataService.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: 'CardanoODataService.LedgerProtocolParameters' })
+Object.defineProperty(LedgerProtocolParameter, 'is_singular', { value: true })
+export class LedgerProtocolParameters extends Array<LedgerProtocolParameter> {$count?: number}
+Object.defineProperty(LedgerProtocolParameters, 'name', { value: 'CardanoODataService.LedgerProtocolParameters' })
+
+
+export declare const GetNetworkInformation:  {
+  // positional
+  (): globalThis.Promise<NetworkInformation | null> | NetworkInformation | null
+  // named
+  ({}: globalThis.Record<never, never>): globalThis.Promise<NetworkInformation | null> | NetworkInformation | null
+  // metadata (do not use)
+  __parameters: globalThis.Record<never, never>, __returns: globalThis.Promise<NetworkInformation | null> | NetworkInformation | null, __self: never
+  kind: 'action'
+}
+
+export declare const GetBlockByHash:  {
+  // positional
+  (hash: _odatano_cardano.Blake2b256 | null): globalThis.Promise<Block | null> | Block | null
+  // named
+  ({hash}: {hash?: _odatano_cardano.Blake2b256 | null}): globalThis.Promise<Block | null> | Block | null
+  // metadata (do not use)
+  __parameters: {hash?: _odatano_cardano.Blake2b256 | null}, __returns: globalThis.Promise<Block | null> | Block | null, __self: never
+  kind: 'action'
+}
+
+export declare const GetEpochByNumber:  {
+  // positional
+  (epochNumber: number | null): globalThis.Promise<Epoch | null> | Epoch | null
+  // named
+  ({epochNumber}: {epochNumber?: number | null}): globalThis.Promise<Epoch | null> | Epoch | null
+  // metadata (do not use)
+  __parameters: {epochNumber?: number | null}, __returns: globalThis.Promise<Epoch | null> | Epoch | null, __self: never
+  kind: 'action'
+}
+
+export declare const GetPoolById:  {
+  // positional
+  (poolId: string | null): globalThis.Promise<Pool | null> | Pool | null
+  // named
+  ({poolId}: {poolId?: string | null}): globalThis.Promise<Pool | null> | Pool | null
+  // metadata (do not use)
+  __parameters: {poolId?: string | null}, __returns: globalThis.Promise<Pool | null> | Pool | null, __self: never
+  kind: 'action'
+}
+
+export declare const GetDrepById:  {
+  // positional
+  (drepId: string | null): globalThis.Promise<Drep | null> | Drep | null
+  // named
+  ({drepId}: {drepId?: string | null}): globalThis.Promise<Drep | null> | Drep | null
+  // metadata (do not use)
+  __parameters: {drepId?: string | null}, __returns: globalThis.Promise<Drep | null> | Drep | null, __self: never
+  kind: 'action'
+}
+
+export declare const GetAccountByStakeAddress:  {
+  // positional
+  (stakeAddress: _odatano_cardano.Bech32 | null): globalThis.Promise<Account | null> | Account | null
+  // named
+  ({stakeAddress}: {stakeAddress?: _odatano_cardano.Bech32 | null}): globalThis.Promise<Account | null> | Account | null
+  // metadata (do not use)
+  __parameters: {stakeAddress?: _odatano_cardano.Bech32 | null}, __returns: globalThis.Promise<Account | null> | Account | null, __self: never
+  kind: 'action'
+}
+
+export declare const GetTransactionByHash:  {
+  // positional
+  (hash: _odatano_cardano.Blake2b256 | null): globalThis.Promise<Transaction | null> | Transaction | null
+  // named
+  ({hash}: {hash?: _odatano_cardano.Blake2b256 | null}): globalThis.Promise<Transaction | null> | Transaction | null
+  // metadata (do not use)
+  __parameters: {hash?: _odatano_cardano.Blake2b256 | null}, __returns: globalThis.Promise<Transaction | null> | Transaction | null, __self: never
+  kind: 'action'
+}
+
+export declare const GetMetadataByTxHash:  {
+  // positional
+  (tx_hash: _odatano_cardano.Blake2b256 | null): globalThis.Promise<Array<TransactionMetadata>> | Array<TransactionMetadata>
+  // named
+  ({tx_hash}: {tx_hash?: _odatano_cardano.Blake2b256 | null}): globalThis.Promise<Array<TransactionMetadata>> | Array<TransactionMetadata>
+  // metadata (do not use)
+  __parameters: {tx_hash?: _odatano_cardano.Blake2b256 | null}, __returns: globalThis.Promise<Array<TransactionMetadata>> | Array<TransactionMetadata>, __self: never
+  kind: 'action'
+}
+
+export declare const GetAddressByBech32:  {
+  // positional
+  (address: _odatano_cardano.Bech32 | null): globalThis.Promise<Address | null> | Address | null
+  // named
+  ({address}: {address?: _odatano_cardano.Bech32 | null}): globalThis.Promise<Address | null> | Address | null
+  // metadata (do not use)
+  __parameters: {address?: _odatano_cardano.Bech32 | null}, __returns: globalThis.Promise<Address | null> | Address | null, __self: never
+  kind: 'action'
+}
+
+export declare const GetUTxOsByAddress:  {
+  // positional
+  (address: _odatano_cardano.Bech32 | null): globalThis.Promise<Array<AddressUTxO>> | Array<AddressUTxO>
+  // named
+  ({address}: {address?: _odatano_cardano.Bech32 | null}): globalThis.Promise<Array<AddressUTxO>> | Array<AddressUTxO>
+  // metadata (do not use)
+  __parameters: {address?: _odatano_cardano.Bech32 | null}, __returns: globalThis.Promise<Array<AddressUTxO>> | Array<AddressUTxO>, __self: never
+  kind: 'action'
+}
+
+export declare const GetAssetsByAddress:  {
+  // positional
+  (address: _odatano_cardano.Bech32 | null): globalThis.Promise<Array<AddressAsset>> | Array<AddressAsset>
+  // named
+  ({address}: {address?: _odatano_cardano.Bech32 | null}): globalThis.Promise<Array<AddressAsset>> | Array<AddressAsset>
+  // metadata (do not use)
+  __parameters: {address?: _odatano_cardano.Bech32 | null}, __returns: globalThis.Promise<Array<AddressAsset>> | Array<AddressAsset>, __self: never
+  kind: 'action'
+}
+
+export declare const GetLatestTransactionsByAddress:  {
+  // positional
+  (address: _odatano_cardano.Bech32 | null, limit: number | null): globalThis.Promise<Array<AddressTransaction>> | Array<AddressTransaction>
+  // named
+  ({address, limit}: {address?: _odatano_cardano.Bech32 | null, limit?: number | null}): globalThis.Promise<Array<AddressTransaction>> | Array<AddressTransaction>
+  // metadata (do not use)
+  __parameters: {address?: _odatano_cardano.Bech32 | null, limit?: number | null}, __returns: globalThis.Promise<Array<AddressTransaction>> | Array<AddressTransaction>, __self: never
+  kind: 'action'
+}
+
+export declare const GetLatestBlock:  {
+  // positional
+  (): globalThis.Promise<Block | null> | Block | null
+  // named
+  ({}: globalThis.Record<never, never>): globalThis.Promise<Block | null> | Block | null
+  // metadata (do not use)
+  __parameters: globalThis.Record<never, never>, __returns: globalThis.Promise<Block | null> | Block | null, __self: never
+  kind: 'action'
+}
+
+export declare const GetLatestEpoch:  {
+  // positional
+  (): globalThis.Promise<Epoch | null> | Epoch | null
+  // named
+  ({}: globalThis.Record<never, never>): globalThis.Promise<Epoch | null> | Epoch | null
+  // metadata (do not use)
+  __parameters: globalThis.Record<never, never>, __returns: globalThis.Promise<Epoch | null> | Epoch | null, __self: never
+  kind: 'action'
+}
+
+export declare const GetLedgerProtocolParameters:  {
+  // positional
+  (): globalThis.Promise<LedgerProtocolParameter | null> | LedgerProtocolParameter | null
+  // named
+  ({}: globalThis.Record<never, never>): globalThis.Promise<LedgerProtocolParameter | null> | LedgerProtocolParameter | null
+  // metadata (do not use)
+  __parameters: globalThis.Record<never, never>, __returns: globalThis.Promise<LedgerProtocolParameter | null> | LedgerProtocolParameter | null, __self: never
+  kind: 'action'
+}