@portkey/graphql 0.0.1-alpha.8.9 → 0.0.2-alpha.2

package/dist/esm/did/__generated__/hooks/caHolderNFTBalanceInfo.js

@@ -0,0 +1,54 @@
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {};
+export const CaHolderNftBalanceInfoDocument = gql `
+  query caHolderNFTBalanceInfo($dto: GetCAHolderNFTInfoDto) {
+    caHolderNFTBalanceInfo(dto: $dto) {
+      totalRecordCount
+      data {
+        id
+        chainId
+        caAddress
+        balance
+        nftInfo {
+          symbol
+          tokenContractAddress
+          decimals
+          supply
+          totalSupply
+          tokenName
+          issuer
+          isBurnable
+          issueChainId
+          imageUrl
+          collectionSymbol
+          collectionName
+        }
+      }
+    }
+  }
+`;
+/**
+ * __useCaHolderNftBalanceInfoQuery__
+ *
+ * To run a query within a React component, call `useCaHolderNftBalanceInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCaHolderNftBalanceInfoQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCaHolderNftBalanceInfoQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export function useCaHolderNftBalanceInfoQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(CaHolderNftBalanceInfoDocument, options);
+}
+export function useCaHolderNftBalanceInfoLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(CaHolderNftBalanceInfoDocument, options);
+}

package/dist/esm/did/__generated__/hooks/caHolderNFTCollectionBalanceInfo.d.ts

@@ -0,0 +1,58 @@
+import * as Types from '../types.js';
+import * as Apollo from '@apollo/client';
+export type CaHolderNftCollectionBalanceInfoQueryVariables = Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderNftCollectionInfoDto>;
+}>;
+export type CaHolderNftCollectionBalanceInfoQuery = {
+    __typename?: 'Query';
+    caHolderNFTCollectionBalanceInfo?: {
+        __typename?: 'CAHolderNFTCollectionBalancePageResultDto';
+        totalRecordCount: number;
+        data?: Array<{
+            __typename?: 'CAHolderNFTCollectionBalanceInfoDto';
+            id?: string | null;
+            chainId?: string | null;
+            caAddress?: string | null;
+            tokenIds?: Array<number> | null;
+            nftCollectionInfo?: {
+                __typename?: 'NFTCollectionDto';
+                symbol?: string | null;
+                tokenContractAddress?: string | null;
+                decimals: number;
+                supply: number;
+                totalSupply: number;
+                tokenName?: string | null;
+                issuer?: string | null;
+                isBurnable: boolean;
+                issueChainId: number;
+                imageUrl?: string | null;
+            } | null;
+        } | null> | null;
+    } | null;
+};
+export declare const CaHolderNftCollectionBalanceInfoDocument: Apollo.DocumentNode;
+/**
+ * __useCaHolderNftCollectionBalanceInfoQuery__
+ *
+ * To run a query within a React component, call `useCaHolderNftCollectionBalanceInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCaHolderNftCollectionBalanceInfoQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCaHolderNftCollectionBalanceInfoQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export declare function useCaHolderNftCollectionBalanceInfoQuery(baseOptions?: Apollo.QueryHookOptions<CaHolderNftCollectionBalanceInfoQuery, CaHolderNftCollectionBalanceInfoQueryVariables>): Apollo.QueryResult<CaHolderNftCollectionBalanceInfoQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderNftCollectionInfoDto> | undefined;
+}>>;
+export declare function useCaHolderNftCollectionBalanceInfoLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CaHolderNftCollectionBalanceInfoQuery, CaHolderNftCollectionBalanceInfoQueryVariables>): Apollo.LazyQueryResultTuple<CaHolderNftCollectionBalanceInfoQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderNftCollectionInfoDto> | undefined;
+}>>;
+export type CaHolderNftCollectionBalanceInfoQueryHookResult = ReturnType<typeof useCaHolderNftCollectionBalanceInfoQuery>;
+export type CaHolderNftCollectionBalanceInfoLazyQueryHookResult = ReturnType<typeof useCaHolderNftCollectionBalanceInfoLazyQuery>;
+export type CaHolderNftCollectionBalanceInfoQueryResult = Apollo.QueryResult<CaHolderNftCollectionBalanceInfoQuery, CaHolderNftCollectionBalanceInfoQueryVariables>;

package/dist/esm/did/__generated__/hooks/caHolderNFTCollectionBalanceInfo.js

@@ -0,0 +1,52 @@
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {};
+export const CaHolderNftCollectionBalanceInfoDocument = gql `
+  query caHolderNFTCollectionBalanceInfo($dto: GetCAHolderNFTCollectionInfoDto) {
+    caHolderNFTCollectionBalanceInfo(dto: $dto) {
+      totalRecordCount
+      data {
+        id
+        chainId
+        caAddress
+        tokenIds
+        nftCollectionInfo {
+          symbol
+          tokenContractAddress
+          decimals
+          supply
+          totalSupply
+          tokenName
+          issuer
+          isBurnable
+          issueChainId
+          imageUrl
+        }
+      }
+    }
+  }
+`;
+/**
+ * __useCaHolderNftCollectionBalanceInfoQuery__
+ *
+ * To run a query within a React component, call `useCaHolderNftCollectionBalanceInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCaHolderNftCollectionBalanceInfoQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCaHolderNftCollectionBalanceInfoQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export function useCaHolderNftCollectionBalanceInfoQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(CaHolderNftCollectionBalanceInfoDocument, options);
+}
+export function useCaHolderNftCollectionBalanceInfoLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(CaHolderNftCollectionBalanceInfoDocument, options);
+}

package/dist/esm/did/__generated__/hooks/caHolderSearchTokenNFT.d.ts

@@ -0,0 +1,77 @@
+import * as Types from '../types.js';
+import * as Apollo from '@apollo/client';
+export type CaHolderSearchTokenNftQueryVariables = Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderSearchTokenNftDto>;
+}>;
+export type CaHolderSearchTokenNftQuery = {
+    __typename?: 'Query';
+    caHolderSearchTokenNFT?: {
+        __typename?: 'CAHolderSearchTokenNFTPageResultDto';
+        totalRecordCount: number;
+        data?: Array<{
+            __typename?: 'CAHolderSearchTokenNFTDto';
+            chainId?: string | null;
+            caAddress?: string | null;
+            balance: number;
+            tokenId: number;
+            tokenInfo?: {
+                __typename?: 'TokenInfoDto';
+                id?: string | null;
+                chainId?: string | null;
+                blockHash?: string | null;
+                blockHeight: number;
+                previousBlockHash?: string | null;
+                symbol?: string | null;
+                type: Types.TokenType;
+                tokenContractAddress?: string | null;
+                decimals: number;
+                totalSupply: number;
+                tokenName?: string | null;
+                issuer?: string | null;
+                isBurnable: boolean;
+                issueChainId: number;
+            } | null;
+            nftInfo?: {
+                __typename?: 'NFTItemInfoDto';
+                symbol?: string | null;
+                tokenContractAddress?: string | null;
+                decimals: number;
+                supply: number;
+                totalSupply: number;
+                tokenName?: string | null;
+                issuer?: string | null;
+                isBurnable: boolean;
+                issueChainId: number;
+                imageUrl?: string | null;
+                collectionSymbol?: string | null;
+                collectionName?: string | null;
+            } | null;
+        } | null> | null;
+    } | null;
+};
+export declare const CaHolderSearchTokenNftDocument: Apollo.DocumentNode;
+/**
+ * __useCaHolderSearchTokenNftQuery__
+ *
+ * To run a query within a React component, call `useCaHolderSearchTokenNftQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCaHolderSearchTokenNftQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCaHolderSearchTokenNftQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export declare function useCaHolderSearchTokenNftQuery(baseOptions?: Apollo.QueryHookOptions<CaHolderSearchTokenNftQuery, CaHolderSearchTokenNftQueryVariables>): Apollo.QueryResult<CaHolderSearchTokenNftQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderSearchTokenNftDto> | undefined;
+}>>;
+export declare function useCaHolderSearchTokenNftLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CaHolderSearchTokenNftQuery, CaHolderSearchTokenNftQueryVariables>): Apollo.LazyQueryResultTuple<CaHolderSearchTokenNftQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderSearchTokenNftDto> | undefined;
+}>>;
+export type CaHolderSearchTokenNftQueryHookResult = ReturnType<typeof useCaHolderSearchTokenNftQuery>;
+export type CaHolderSearchTokenNftLazyQueryHookResult = ReturnType<typeof useCaHolderSearchTokenNftLazyQuery>;
+export type CaHolderSearchTokenNftQueryResult = Apollo.QueryResult<CaHolderSearchTokenNftQuery, CaHolderSearchTokenNftQueryVariables>;

package/dist/esm/did/__generated__/hooks/caHolderSearchTokenNFT.js

@@ -0,0 +1,70 @@
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {};
+export const CaHolderSearchTokenNftDocument = gql `
+  query caHolderSearchTokenNFT($dto: GetCAHolderSearchTokenNFTDto) {
+    caHolderSearchTokenNFT(dto: $dto) {
+      totalRecordCount
+      data {
+        chainId
+        caAddress
+        balance
+        tokenId
+        tokenInfo {
+          id
+          chainId
+          blockHash
+          blockHeight
+          previousBlockHash
+          symbol
+          type
+          tokenContractAddress
+          decimals
+          totalSupply
+          tokenName
+          issuer
+          isBurnable
+          issueChainId
+        }
+        nftInfo {
+          symbol
+          tokenContractAddress
+          decimals
+          supply
+          totalSupply
+          tokenName
+          issuer
+          isBurnable
+          issueChainId
+          imageUrl
+          collectionSymbol
+          collectionName
+        }
+      }
+    }
+  }
+`;
+/**
+ * __useCaHolderSearchTokenNftQuery__
+ *
+ * To run a query within a React component, call `useCaHolderSearchTokenNftQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCaHolderSearchTokenNftQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCaHolderSearchTokenNftQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export function useCaHolderSearchTokenNftQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(CaHolderSearchTokenNftDocument, options);
+}
+export function useCaHolderSearchTokenNftLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(CaHolderSearchTokenNftDocument, options);
+}

package/dist/esm/did/__generated__/hooks/caHolderTokenBalanceInfo.d.ts

@@ -0,0 +1,62 @@
+import * as Types from '../types.js';
+import * as Apollo from '@apollo/client';
+export type CaHolderTokenBalanceInfoQueryVariables = Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderTokenBalanceDto>;
+}>;
+export type CaHolderTokenBalanceInfoQuery = {
+    __typename?: 'Query';
+    caHolderTokenBalanceInfo?: {
+        __typename?: 'CAHolderTokenBalancePageResultDto';
+        totalRecordCount: number;
+        data?: Array<{
+            __typename?: 'CAHolderTokenBalanceDto';
+            chainId?: string | null;
+            caAddress?: string | null;
+            balance: number;
+            tokenIds?: Array<number> | null;
+            tokenInfo?: {
+                __typename?: 'TokenInfoDto';
+                id?: string | null;
+                chainId?: string | null;
+                blockHash?: string | null;
+                blockHeight: number;
+                previousBlockHash?: string | null;
+                symbol?: string | null;
+                type: Types.TokenType;
+                tokenContractAddress?: string | null;
+                decimals: number;
+                totalSupply: number;
+                tokenName?: string | null;
+                issuer?: string | null;
+                isBurnable: boolean;
+                issueChainId: number;
+            } | null;
+        } | null> | null;
+    } | null;
+};
+export declare const CaHolderTokenBalanceInfoDocument: Apollo.DocumentNode;
+/**
+ * __useCaHolderTokenBalanceInfoQuery__
+ *
+ * To run a query within a React component, call `useCaHolderTokenBalanceInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCaHolderTokenBalanceInfoQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCaHolderTokenBalanceInfoQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export declare function useCaHolderTokenBalanceInfoQuery(baseOptions?: Apollo.QueryHookOptions<CaHolderTokenBalanceInfoQuery, CaHolderTokenBalanceInfoQueryVariables>): Apollo.QueryResult<CaHolderTokenBalanceInfoQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderTokenBalanceDto> | undefined;
+}>>;
+export declare function useCaHolderTokenBalanceInfoLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CaHolderTokenBalanceInfoQuery, CaHolderTokenBalanceInfoQueryVariables>): Apollo.LazyQueryResultTuple<CaHolderTokenBalanceInfoQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderTokenBalanceDto> | undefined;
+}>>;
+export type CaHolderTokenBalanceInfoQueryHookResult = ReturnType<typeof useCaHolderTokenBalanceInfoQuery>;
+export type CaHolderTokenBalanceInfoLazyQueryHookResult = ReturnType<typeof useCaHolderTokenBalanceInfoLazyQuery>;
+export type CaHolderTokenBalanceInfoQueryResult = Apollo.QueryResult<CaHolderTokenBalanceInfoQuery, CaHolderTokenBalanceInfoQueryVariables>;

package/dist/esm/did/__generated__/hooks/caHolderTokenBalanceInfo.js

@@ -0,0 +1,56 @@
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {};
+export const CaHolderTokenBalanceInfoDocument = gql `
+  query caHolderTokenBalanceInfo($dto: GetCAHolderTokenBalanceDto) {
+    caHolderTokenBalanceInfo(dto: $dto) {
+      totalRecordCount
+      data {
+        chainId
+        caAddress
+        tokenInfo {
+          id
+          chainId
+          blockHash
+          blockHeight
+          previousBlockHash
+          symbol
+          type
+          tokenContractAddress
+          decimals
+          totalSupply
+          tokenName
+          issuer
+          isBurnable
+          issueChainId
+        }
+        balance
+        tokenIds
+      }
+    }
+  }
+`;
+/**
+ * __useCaHolderTokenBalanceInfoQuery__
+ *
+ * To run a query within a React component, call `useCaHolderTokenBalanceInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCaHolderTokenBalanceInfoQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCaHolderTokenBalanceInfoQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export function useCaHolderTokenBalanceInfoQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(CaHolderTokenBalanceInfoDocument, options);
+}
+export function useCaHolderTokenBalanceInfoLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(CaHolderTokenBalanceInfoDocument, options);
+}

package/dist/esm/did/__generated__/hooks/caHolderTransaction.d.ts

@@ -0,0 +1,98 @@
+import * as Types from '../types.js';
+import * as Apollo from '@apollo/client';
+export type CaHolderTransactionQueryVariables = Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderTransactionDto>;
+}>;
+export type CaHolderTransactionQuery = {
+    __typename?: 'Query';
+    caHolderTransaction?: {
+        __typename?: 'CAHolderTransactionPageResultDto';
+        totalRecordCount: number;
+        data?: Array<{
+            __typename?: 'CAHolderTransactionDto';
+            id?: string | null;
+            chainId?: string | null;
+            blockHash?: string | null;
+            blockHeight: number;
+            previousBlockHash?: string | null;
+            transactionId?: string | null;
+            methodName?: string | null;
+            status: Types.TransactionStatus;
+            timestamp: number;
+            fromAddress?: string | null;
+            tokenInfo?: {
+                __typename?: 'TokenInfoDto';
+                id?: string | null;
+                chainId?: string | null;
+                blockHash?: string | null;
+                blockHeight: number;
+                previousBlockHash?: string | null;
+                symbol?: string | null;
+                type: Types.TokenType;
+                tokenContractAddress?: string | null;
+                decimals: number;
+                totalSupply: number;
+                tokenName?: string | null;
+                issuer?: string | null;
+                isBurnable: boolean;
+                issueChainId: number;
+            } | null;
+            nftInfo?: {
+                __typename?: 'NFTItemInfoDto';
+                symbol?: string | null;
+                tokenContractAddress?: string | null;
+                decimals: number;
+                supply: number;
+                totalSupply: number;
+                tokenName?: string | null;
+                issuer?: string | null;
+                isBurnable: boolean;
+                issueChainId: number;
+                imageUrl?: string | null;
+                collectionSymbol?: string | null;
+                collectionName?: string | null;
+            } | null;
+            transferInfo?: {
+                __typename?: 'TransferInfo';
+                fromAddress?: string | null;
+                fromCAAddress?: string | null;
+                toAddress?: string | null;
+                amount: number;
+                fromChainId?: string | null;
+                toChainId?: string | null;
+                transferTransactionId?: string | null;
+            } | null;
+            transactionFees?: Array<{
+                __typename?: 'TransactionFee';
+                symbol?: string | null;
+                amount: number;
+            } | null> | null;
+        } | null> | null;
+    } | null;
+};
+export declare const CaHolderTransactionDocument: Apollo.DocumentNode;
+/**
+ * __useCaHolderTransactionQuery__
+ *
+ * To run a query within a React component, call `useCaHolderTransactionQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCaHolderTransactionQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCaHolderTransactionQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export declare function useCaHolderTransactionQuery(baseOptions?: Apollo.QueryHookOptions<CaHolderTransactionQuery, CaHolderTransactionQueryVariables>): Apollo.QueryResult<CaHolderTransactionQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderTransactionDto> | undefined;
+}>>;
+export declare function useCaHolderTransactionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CaHolderTransactionQuery, CaHolderTransactionQueryVariables>): Apollo.LazyQueryResultTuple<CaHolderTransactionQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderTransactionDto> | undefined;
+}>>;
+export type CaHolderTransactionQueryHookResult = ReturnType<typeof useCaHolderTransactionQuery>;
+export type CaHolderTransactionLazyQueryHookResult = ReturnType<typeof useCaHolderTransactionLazyQuery>;
+export type CaHolderTransactionQueryResult = Apollo.QueryResult<CaHolderTransactionQuery, CaHolderTransactionQueryVariables>;

package/dist/esm/did/__generated__/hooks/caHolderTransaction.js

@@ -0,0 +1,89 @@
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {};
+export const CaHolderTransactionDocument = gql `
+  query caHolderTransaction($dto: GetCAHolderTransactionDto) {
+    caHolderTransaction(dto: $dto) {
+      totalRecordCount
+      data {
+        id
+        chainId
+        blockHash
+        blockHeight
+        previousBlockHash
+        transactionId
+        methodName
+        tokenInfo {
+          id
+          chainId
+          blockHash
+          blockHeight
+          previousBlockHash
+          symbol
+          type
+          tokenContractAddress
+          decimals
+          totalSupply
+          tokenName
+          issuer
+          isBurnable
+          issueChainId
+        }
+        nftInfo {
+          symbol
+          tokenContractAddress
+          decimals
+          supply
+          totalSupply
+          tokenName
+          issuer
+          isBurnable
+          issueChainId
+          imageUrl
+          collectionSymbol
+          collectionName
+        }
+        status
+        timestamp
+        transferInfo {
+          fromAddress
+          fromCAAddress
+          toAddress
+          amount
+          fromChainId
+          toChainId
+          transferTransactionId
+        }
+        fromAddress
+        transactionFees {
+          symbol
+          amount
+        }
+      }
+    }
+  }
+`;
+/**
+ * __useCaHolderTransactionQuery__
+ *
+ * To run a query within a React component, call `useCaHolderTransactionQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCaHolderTransactionQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCaHolderTransactionQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export function useCaHolderTransactionQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(CaHolderTransactionDocument, options);
+}
+export function useCaHolderTransactionLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(CaHolderTransactionDocument, options);
+}

package/dist/esm/did/__generated__/hooks/caHolderTransactionAddressInfo.d.ts

@@ -0,0 +1,46 @@
+import * as Types from '../types.js';
+import * as Apollo from '@apollo/client';
+export type CaHolderTransactionAddressInfoQueryVariables = Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderTransactionAddressDto>;
+}>;
+export type CaHolderTransactionAddressInfoQuery = {
+    __typename?: 'Query';
+    caHolderTransactionAddressInfo?: {
+        __typename?: 'CAHolderTransactionAddressPageResultDto';
+        totalRecordCount: number;
+        data?: Array<{
+            __typename?: 'CAHolderTransactionAddressDto';
+            chainId?: string | null;
+            caAddress?: string | null;
+            address?: string | null;
+            addressChainId?: string | null;
+            transactionTime: number;
+        } | null> | null;
+    } | null;
+};
+export declare const CaHolderTransactionAddressInfoDocument: Apollo.DocumentNode;
+/**
+ * __useCaHolderTransactionAddressInfoQuery__
+ *
+ * To run a query within a React component, call `useCaHolderTransactionAddressInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCaHolderTransactionAddressInfoQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCaHolderTransactionAddressInfoQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export declare function useCaHolderTransactionAddressInfoQuery(baseOptions?: Apollo.QueryHookOptions<CaHolderTransactionAddressInfoQuery, CaHolderTransactionAddressInfoQueryVariables>): Apollo.QueryResult<CaHolderTransactionAddressInfoQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderTransactionAddressDto> | undefined;
+}>>;
+export declare function useCaHolderTransactionAddressInfoLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CaHolderTransactionAddressInfoQuery, CaHolderTransactionAddressInfoQueryVariables>): Apollo.LazyQueryResultTuple<CaHolderTransactionAddressInfoQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderTransactionAddressDto> | undefined;
+}>>;
+export type CaHolderTransactionAddressInfoQueryHookResult = ReturnType<typeof useCaHolderTransactionAddressInfoQuery>;
+export type CaHolderTransactionAddressInfoLazyQueryHookResult = ReturnType<typeof useCaHolderTransactionAddressInfoLazyQuery>;
+export type CaHolderTransactionAddressInfoQueryResult = Apollo.QueryResult<CaHolderTransactionAddressInfoQuery, CaHolderTransactionAddressInfoQueryVariables>;