cardano-graphql-ts - npm Package Compare versions

Comparing version 0.1.0 to 0.1.1-alpha.0

index.ts

@@ -9,14 +9,35 @@ export type Maybe<T> = T | null;
   Float: number;
+  PositiveInt: any;
+  DateTime: any;
   BigInt: any;
-  DateTime: any;
+  PublicKeyHash: any;
+  Lovelaces: any;
+  Percentage: any;
+  StakePoolTicker: any;
+  TransactionHash: any;
 };
 
+export type Address = {
+  __typename?: "Address";
+  addressType: AddressType;
+  delegation?: Maybe<StakePool>;
+};
+
+export enum AddressType {
+  Base = "Base",
+  Pointer = "Pointer",
+  Enterprise = "Enterprise"
+}
+
 export type Block = {
   __typename?: "Block";
+  createdAt: Scalars["DateTime"];
+  epoch?: Maybe<Epoch>;
+  fees: Scalars["Int"];
   id: Scalars["ID"];
   merkelRootHash?: Maybe<Scalars["String"]>;
   number: Scalars["Int"];
-  previousBlockNo?: Maybe<Scalars["Int"]>;
-  size: Scalars["Float"];
-  slotNo?: Maybe<Scalars["Int"]>;
+  previousBlock?: Maybe<Block>;
+  size: Scalars["BigInt"];
+  slot: Slot;
   transactions: Array<Maybe<Transaction>>;
@@ -27,36 +48,371 @@ };
   limit?: Maybe<Scalars["Int"]>;
+  orderBy?: Maybe<Array<Transactions_Order_By>>;
+  offset?: Maybe<Scalars["Int"]>;
 };
 
-export type BlockFilter = {
-  ids?: Maybe<Array<Maybe<Scalars["ID"]>>>;
-  numbers?: Maybe<Array<Maybe<Scalars["Int"]>>>;
+export type Blocks_Filter = {
+  dateCreated?: Maybe<Date_Comparison_Exp>;
+  id?: Maybe<Id_Comparison_Exp>;
+  number?: Maybe<Int_Comparison_Exp>;
 };
 
-export type Ledger = {
-  __typename?: "Ledger";
-  blockHeight: Scalars["Int"];
+export type Blocks_Order_By = {
+  number?: Maybe<Order_By>;
+  size?: Maybe<Order_By>;
 };
 
+export enum ByronAddressKind {
+  Redeem = "redeem",
+  Script = "script",
+  Spending = "spending",
+  Staking = "staking"
+}
+
+export type Cardano = {
+  __typename?: "Cardano";
+  blockHeight: Scalars["BigInt"];
+  configuration: Configuration;
+  currentEpoch: Epoch;
+  latestBlock: Block;
+  stakeDistribution: Array<StakePool>;
+};
+
+export type CardanoStakeDistributionArgs = {
+  limit?: Maybe<Scalars["PositiveInt"]>;
+  order_by?: Maybe<Array<StakePools_Order_By>>;
+  offset?: Maybe<Scalars["PositiveInt"]>;
+  where?: Maybe<StakePools_Filter>;
+};
+
+export type Configuration = {
+  __typename?: "Configuration";
+  fees?: Maybe<FeeConfiguration>;
+  networkType?: Maybe<NetworkType>;
+};
+
+export enum Currency {
+  Ada = "ADA"
+}
+
+export type CurrencyValue = {
+  __typename?: "CurrencyValue";
+  currency: Currency;
+  amount: Scalars["BigInt"];
+};
+
+export type Date_Comparison_Exp = {
+  _eq?: Maybe<Scalars["DateTime"]>;
+  _gt?: Maybe<Scalars["DateTime"]>;
+  _gte?: Maybe<Scalars["DateTime"]>;
+  _in?: Maybe<Array<Maybe<Scalars["DateTime"]>>>;
+  _lt?: Maybe<Scalars["DateTime"]>;
+  _lte?: Maybe<Scalars["DateTime"]>;
+  _neq?: Maybe<Scalars["DateTime"]>;
+  _nin?: Maybe<Array<Maybe<Scalars["DateTime"]>>>;
+};
+
+export type Epoch = {
+  __typename?: "Epoch";
+  blocks?: Maybe<Array<Maybe<Block>>>;
+  endedAt?: Maybe<Scalars["DateTime"]>;
+  output?: Maybe<Array<Maybe<CurrencyValue>>>;
+  number: Scalars["Int"];
+  slots?: Maybe<Array<Slot>>;
+  stakeDistribution?: Maybe<Array<StakePool>>;
+  startedAt?: Maybe<Scalars["DateTime"]>;
+  transactions?: Maybe<Array<Maybe<Transaction>>>;
+  transactionsCount?: Maybe<Scalars["Int"]>;
+};
+
+export type Epochs_Filter = {
+  afterDate?: Maybe<Scalars["DateTime"]>;
+  beforeDate?: Maybe<Scalars["DateTime"]>;
+  number?: Maybe<Int_Comparison_Exp>;
+};
+
+export type Epochs_Order_By = {
+  blockCount?: Maybe<Order_By>;
+  number?: Maybe<Order_By>;
+  fees?: Maybe<Order_By>;
+};
+
+export type FeeConfiguration = {
+  __typename?: "FeeConfiguration";
+  base?: Maybe<Scalars["Lovelaces"]>;
+  coefficient?: Maybe<Scalars["Lovelaces"]>;
+};
+
+export type Id_Comparison_Exp = {
+  _eq?: Maybe<Scalars["String"]>;
+  _in?: Maybe<Array<Maybe<Scalars["String"]>>>;
+  _nin?: Maybe<Array<Maybe<Scalars["String"]>>>;
+};
+
+export type Int_Comparison_Exp = {
+  _eq?: Maybe<Scalars["Int"]>;
+  _gt?: Maybe<Scalars["Int"]>;
+  _gte?: Maybe<Scalars["Int"]>;
+  _in?: Maybe<Array<Scalars["Int"]>>;
+  _is_null?: Maybe<Scalars["Boolean"]>;
+  _lt?: Maybe<Scalars["Int"]>;
+  _lte?: Maybe<Scalars["Int"]>;
+  _neq?: Maybe<Scalars["Int"]>;
+  _nin?: Maybe<Array<Scalars["Int"]>>;
+};
+
+export enum JormungandrAddressKind {
+  Account = "account",
+  Grouped = "grouped",
+  Multisig = "multisig",
+  Single = "single"
+}
+
+export type Lovelaces_Comparison_Exp = {
+  _eq?: Maybe<Scalars["Lovelaces"]>;
+  _gt?: Maybe<Scalars["Lovelaces"]>;
+  _gte?: Maybe<Scalars["Lovelaces"]>;
+  _in?: Maybe<Array<Scalars["Lovelaces"]>>;
+  _lt?: Maybe<Scalars["Lovelaces"]>;
+  _lte?: Maybe<Scalars["Lovelaces"]>;
+  _neq?: Maybe<Scalars["Lovelaces"]>;
+  _nin?: Maybe<Array<Scalars["Lovelaces"]>>;
+};
+
+export type Mutation = {
+  __typename?: "Mutation";
+  delegateStake: Scalars["Boolean"];
+  registerStakePool: Scalars["Boolean"];
+  submitTransaction: Scalars["Boolean"];
+};
+
+export type MutationDelegateStakeArgs = {
+  transaction?: Maybe<Scalars["TransactionHash"]>;
+};
+
+export type MutationRegisterStakePoolArgs = {
+  transaction?: Maybe<Scalars["TransactionHash"]>;
+};
+
+export type MutationSubmitTransactionArgs = {
+  transaction?: Maybe<Scalars["TransactionHash"]>;
+};
+
+export enum NetworkType {
+  JormungandrTestnet = "JormungandrTestnet",
+  Mainnet = "Mainnet",
+  Testnet = "Testnet"
+}
+
+export enum Order_By {
+  Asc = "asc",
+  Desc = "desc"
+}
+
+export enum Order_By_With_Nulls {
+  Asc = "asc",
+  AscNullsFirst = "asc_nulls_first",
+  AscNullsLast = "asc_nulls_last",
+  Desc = "desc",
+  DescNullsFirst = "desc_nulls_first",
+  DescNullsLast = "desc_nulls_last"
+}
+
+export type Percentage_Comparison_Exp = {
+  _eq?: Maybe<Scalars["Percentage"]>;
+  _gt?: Maybe<Scalars["Percentage"]>;
+  _gte?: Maybe<Scalars["Percentage"]>;
+  _lt?: Maybe<Scalars["Int"]>;
+  _lte?: Maybe<Scalars["Int"]>;
+  _neq?: Maybe<Scalars["Int"]>;
+};
+
 export type Query = {
   __typename?: "Query";
   blocks: Array<Maybe<Block>>;
+  epochs: Array<Maybe<Epoch>>;
+  cardano?: Maybe<Cardano>;
+  stakeDelegations: Array<Maybe<StakeDelegation>>;
+  stakeholders: Array<Stakeholder>;
+  stakePools: Array<StakePool>;
   transactions: Array<Maybe<Transaction>>;
-  ledger?: Maybe<Ledger>;
+  utxoSet: Array<Maybe<TransactionOutput>>;
 };
 
 export type QueryBlocksArgs = {
-  filter: BlockFilter;
-  first?: Maybe<Scalars["Int"]>;
+  limit?: Maybe<Scalars["PositiveInt"]>;
+  order_by?: Maybe<Array<Blocks_Order_By>>;
+  offset?: Maybe<Scalars["PositiveInt"]>;
+  where?: Maybe<Blocks_Filter>;
 };
 
+export type QueryEpochsArgs = {
+  limit?: Maybe<Scalars["PositiveInt"]>;
+  order_by?: Maybe<Array<Epochs_Order_By>>;
+  offset?: Maybe<Scalars["PositiveInt"]>;
+  where?: Maybe<Epochs_Filter>;
+};
+
+export type QueryStakeDelegationsArgs = {
+  limit?: Maybe<Scalars["PositiveInt"]>;
+  order_by?: Maybe<Array<StakeDelegations_Order_By>>;
+  offset?: Maybe<Scalars["PositiveInt"]>;
+  where?: Maybe<StakeDelegations_Filter>;
+};
+
+export type QueryStakeholdersArgs = {
+  limit?: Maybe<Scalars["PositiveInt"]>;
+  order_by?: Maybe<Array<Stakeholders_Order_By>>;
+  offset?: Maybe<Scalars["PositiveInt"]>;
+  where?: Maybe<Stakeholders_Filter>;
+};
+
+export type QueryStakePoolsArgs = {
+  limit?: Maybe<Scalars["PositiveInt"]>;
+  order_by?: Maybe<Array<StakePools_Order_By>>;
+  offset?: Maybe<Scalars["PositiveInt"]>;
+  where?: Maybe<StakePools_Filter>;
+};
+
 export type QueryTransactionsArgs = {
-  filter: TransactionFilter;
-  first?: Maybe<Scalars["Int"]>;
+  limit?: Maybe<Scalars["PositiveInt"]>;
+  order_by?: Maybe<Array<Transactions_Order_By>>;
+  offset?: Maybe<Scalars["PositiveInt"]>;
+  where?: Maybe<Transactions_Filter>;
 };
 
+export type QueryUtxoSetArgs = {
+  limit?: Maybe<Scalars["PositiveInt"]>;
+  order_by?: Maybe<Array<UtxoSet_Order_By>>;
+  offset?: Maybe<Scalars["PositiveInt"]>;
+  where?: Maybe<UtxoSet_Filter>;
+};
+
+export type RewardAccount = {
+  __typename?: "RewardAccount";
+  address?: Maybe<Scalars["PublicKeyHash"]>;
+  amount?: Maybe<Scalars["Lovelaces"]>;
+};
+
+export type RewardPayout = {
+  __typename?: "RewardPayout";
+  rewardAccount?: Maybe<RewardAccount>;
+  slot?: Maybe<Slot>;
+};
+
+export type Slot = {
+  __typename?: "Slot";
+  block?: Maybe<Block>;
+  epoch: Epoch;
+  leader?: Maybe<Scalars["PublicKeyHash"]>;
+  number: Scalars["Int"];
+  rewardPayouts: Array<Maybe<RewardPayout>>;
+  startedAt?: Maybe<Scalars["DateTime"]>;
+};
+
+export type StakeDelegation = {
+  __typename?: "StakeDelegation";
+  rewardAccount: RewardAccount;
+  stakingKey: Scalars["PublicKeyHash"];
+  stakePool: StakePool;
+};
+
+export type StakeDelegations_Filter = {
+  rewardAccountAddress?: Maybe<Id_Comparison_Exp>;
+  rewardBalance?: Maybe<Int_Comparison_Exp>;
+  stakingKey?: Maybe<Id_Comparison_Exp>;
+};
+
+export type StakeDelegations_Order_By = {
+  rewardBalance?: Maybe<Order_By>;
+  stakingKey?: Maybe<Order_By>;
+};
+
+export type Stakeholder = {
+  __typename?: "Stakeholder";
+  delegations?: Maybe<Array<Maybe<StakeDelegation>>>;
+  totalRewardBalance: Scalars["Lovelaces"];
+};
+
+export type StakeholderDelegationsArgs = {
+  limit?: Maybe<Scalars["PositiveInt"]>;
+  order_by?: Maybe<Array<StakeDelegations_Order_By>>;
+  offset?: Maybe<Scalars["PositiveInt"]>;
+  where?: Maybe<StakeDelegations_Filter>;
+};
+
+export type Stakeholders_Filter = {
+  stakingKey?: Maybe<Id_Comparison_Exp>;
+  totalRewardBalance?: Maybe<Int_Comparison_Exp>;
+};
+
+export type Stakeholders_Order_By = {
+  stakingKey?: Maybe<Order_By>;
+  totalRewardBalance?: Maybe<Order_By>;
+};
+
+export type StakePool = {
+  __typename?: "StakePool";
+  controlledStake: Scalars["Lovelaces"];
+  createdAt: Scalars["DateTime"];
+  description: Scalars["String"];
+  id: Scalars["PublicKeyHash"];
+  isCharity: Scalars["Boolean"];
+  pledgedStake: Scalars["Lovelaces"];
+  performance?: Maybe<Scalars["Percentage"]>;
+  profitMargin: Scalars["Int"];
+  name: Scalars["String"];
+  ranking: Scalars["Int"];
+  retirementEpochNumber?: Maybe<Scalars["Int"]>;
+  slotsElected: Array<Maybe<Slot>>;
+  ticker: Scalars["StakePoolTicker"];
+  url: Scalars["String"];
+};
+
+export type StakePools_Filter = {
+  createdAt?: Maybe<Date_Comparison_Exp>;
+  controlledStake?: Maybe<Lovelaces_Comparison_Exp>;
+  isCharity?: Maybe<Scalars["Boolean"]>;
+  pledgedStake?: Maybe<Lovelaces_Comparison_Exp>;
+  performance?: Maybe<Percentage_Comparison_Exp>;
+  profitMargin?: Maybe<Int_Comparison_Exp>;
+  ranking?: Maybe<Int_Comparison_Exp>;
+  retiring?: Maybe<Scalars["Boolean"]>;
+};
+
+export type StakePools_Order_By = {
+  createdAt?: Maybe<Order_By>;
+  controlledStake?: Maybe<Order_By>;
+  isCharity?: Maybe<Order_By>;
+  pledgedStake?: Maybe<Order_By>;
+  performance?: Maybe<Order_By>;
+  profitMargin?: Maybe<Order_By>;
+  name?: Maybe<Order_By>;
+  ranking?: Maybe<Order_By>;
+  retiring?: Maybe<Order_By>;
+};
+
+export type Text_Comparison_Exp = {
+  _eq?: Maybe<Scalars["String"]>;
+  _gt?: Maybe<Scalars["String"]>;
+  _gte?: Maybe<Scalars["String"]>;
+  _ilike?: Maybe<Scalars["String"]>;
+  _in?: Maybe<Array<Maybe<Scalars["String"]>>>;
+  _is_null?: Maybe<Scalars["Boolean"]>;
+  _like?: Maybe<Scalars["String"]>;
+  _lt?: Maybe<Scalars["String"]>;
+  _lte?: Maybe<Scalars["String"]>;
+  _neq?: Maybe<Scalars["String"]>;
+  _nilike?: Maybe<Scalars["String"]>;
+  _nin?: Maybe<Array<Maybe<Scalars["String"]>>>;
+  _nlike?: Maybe<Scalars["String"]>;
+  _nsimilar?: Maybe<Scalars["String"]>;
+  _similar?: Maybe<Scalars["String"]>;
+};
+
 export type Transaction = {
   __typename?: "Transaction";
-  blockNo?: Maybe<Scalars["Int"]>;
+  block?: Maybe<Block>;
   fee: Scalars["Int"];
   id: Scalars["String"];
+  includedAt: Scalars["DateTime"];
   inputs: Array<Maybe<TransactionInput>>;
@@ -66,12 +422,8 @@ outputs: Array<TransactionOutput>;
 
-export type TransactionFilter = {
-  ids?: Maybe<Array<Maybe<Scalars["ID"]>>>;
-};
-
 export type TransactionInput = {
   __typename?: "TransactionInput";
+  address: Scalars["String"];
   sourceTxId: Scalars["String"];
   sourceTxIndex: Scalars["Int"];
-  address: Scalars["String"];
-  value: Scalars["BigInt"];
+  value: CurrencyValue;
 };
@@ -81,6 +433,24 @@
   __typename?: "TransactionOutput";
+  address: Scalars["String"];
+  index: Scalars["Int"];
   txId: Scalars["String"];
-  index: Scalars["Int"];
-  value: Scalars["BigInt"];
-  address: Scalars["String"];
+  value: CurrencyValue;
 };
+
+export type Transactions_Filter = {
+  id?: Maybe<Id_Comparison_Exp>;
+  block?: Maybe<Blocks_Filter>;
+};
+
+export type Transactions_Order_By = {
+  block?: Maybe<Order_By>;
+  fee?: Maybe<Order_By>;
+};
+
+export type UtxoSet_Filter = {
+  address?: Maybe<Text_Comparison_Exp>;
+};
+
+export type UtxoSet_Order_By = {
+  address?: Maybe<Order_By>;
+};

package.json

 {
   "name": "cardano-graphql-ts",
-  "version": "0.1.0",
-  "description": "TypeScript definitions for Cardano GraphQL",
+  "version": "0.1.1-alpha.0",
+  "description": "Generated TypeScript definitions for Cardano GraphQL",
   "repository": {
@@ -9,2 +9,4 @@ "type": "git",
   },
+  "main": "",
+  "scripts": {},
   "keywords": [
@@ -11,0 +13,0 @@ "Cardano",

README.md

 # Cardano GraphQL: TypeScript Definition
-Statically check queries before sending to the server
+Generated using [GraphQL Code Generator](https://graphql-code-generator.com/docs/plugins/typescript), published to npm via a build job.

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

24356

increased by69.97%

Lines of code

394

increased by454.93%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes