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

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

@@ -0,0 +1,41 @@
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {};
+export const CaHolderTransactionAddressInfoDocument = gql `
+  query caHolderTransactionAddressInfo($dto: GetCAHolderTransactionAddressDto) {
+    caHolderTransactionAddressInfo(dto: $dto) {
+      totalRecordCount
+      data {
+        chainId
+        caAddress
+        address
+        addressChainId
+        transactionTime
+      }
+    }
+  }
+`;
+/**
+ * __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 function useCaHolderTransactionAddressInfoQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(CaHolderTransactionAddressInfoDocument, options);
+}
+export function useCaHolderTransactionAddressInfoLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(CaHolderTransactionAddressInfoDocument, options);
+}

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

@@ -0,0 +1,98 @@
+import * as Types from '../types.js';
+import * as Apollo from '@apollo/client';
+export type CaHolderTransactionInfoQueryVariables = Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderTransactionDto>;
+}>;
+export type CaHolderTransactionInfoQuery = {
+    __typename?: 'Query';
+    caHolderTransactionInfo?: {
+        __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 CaHolderTransactionInfoDocument: Apollo.DocumentNode;
+/**
+ * __useCaHolderTransactionInfoQuery__
+ *
+ * To run a query within a React component, call `useCaHolderTransactionInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCaHolderTransactionInfoQuery` 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 } = useCaHolderTransactionInfoQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export declare function useCaHolderTransactionInfoQuery(baseOptions?: Apollo.QueryHookOptions<CaHolderTransactionInfoQuery, CaHolderTransactionInfoQueryVariables>): Apollo.QueryResult<CaHolderTransactionInfoQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderTransactionDto> | undefined;
+}>>;
+export declare function useCaHolderTransactionInfoLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CaHolderTransactionInfoQuery, CaHolderTransactionInfoQueryVariables>): Apollo.LazyQueryResultTuple<CaHolderTransactionInfoQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetCaHolderTransactionDto> | undefined;
+}>>;
+export type CaHolderTransactionInfoQueryHookResult = ReturnType<typeof useCaHolderTransactionInfoQuery>;
+export type CaHolderTransactionInfoLazyQueryHookResult = ReturnType<typeof useCaHolderTransactionInfoLazyQuery>;
+export type CaHolderTransactionInfoQueryResult = Apollo.QueryResult<CaHolderTransactionInfoQuery, CaHolderTransactionInfoQueryVariables>;

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

@@ -0,0 +1,89 @@
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {};
+export const CaHolderTransactionInfoDocument = gql `
+  query caHolderTransactionInfo($dto: GetCAHolderTransactionDto) {
+    caHolderTransactionInfo(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
+        }
+      }
+    }
+  }
+`;
+/**
+ * __useCaHolderTransactionInfoQuery__
+ *
+ * To run a query within a React component, call `useCaHolderTransactionInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCaHolderTransactionInfoQuery` 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 } = useCaHolderTransactionInfoQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export function useCaHolderTransactionInfoQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(CaHolderTransactionInfoDocument, options);
+}
+export function useCaHolderTransactionInfoLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(CaHolderTransactionInfoDocument, options);
+}

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

@@ -0,0 +1,52 @@
+import * as Types from '../types.js';
+import * as Apollo from '@apollo/client';
+export type LoginGuardianChangeRecordInfoQueryVariables = Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetLoginGuardianChangeRecordDto>;
+}>;
+export type LoginGuardianChangeRecordInfoQuery = {
+    __typename?: 'Query';
+    loginGuardianChangeRecordInfo?: Array<{
+        __typename?: 'LoginGuardianChangeRecordDto';
+        changeType?: string | null;
+        blockHeight: number;
+        id?: string | null;
+        chainId?: string | null;
+        caHash?: string | null;
+        caAddress?: string | null;
+        manager?: string | null;
+        loginGuardian?: {
+            __typename?: 'GuardianDto';
+            type: number;
+            verifierId?: string | null;
+            identifierHash?: string | null;
+            salt?: string | null;
+            isLoginGuardian: boolean;
+        } | null;
+    } | null> | null;
+};
+export declare const LoginGuardianChangeRecordInfoDocument: Apollo.DocumentNode;
+/**
+ * __useLoginGuardianChangeRecordInfoQuery__
+ *
+ * To run a query within a React component, call `useLoginGuardianChangeRecordInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useLoginGuardianChangeRecordInfoQuery` 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 } = useLoginGuardianChangeRecordInfoQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export declare function useLoginGuardianChangeRecordInfoQuery(baseOptions?: Apollo.QueryHookOptions<LoginGuardianChangeRecordInfoQuery, LoginGuardianChangeRecordInfoQueryVariables>): Apollo.QueryResult<LoginGuardianChangeRecordInfoQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetLoginGuardianChangeRecordDto> | undefined;
+}>>;
+export declare function useLoginGuardianChangeRecordInfoLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<LoginGuardianChangeRecordInfoQuery, LoginGuardianChangeRecordInfoQueryVariables>): Apollo.LazyQueryResultTuple<LoginGuardianChangeRecordInfoQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetLoginGuardianChangeRecordDto> | undefined;
+}>>;
+export type LoginGuardianChangeRecordInfoQueryHookResult = ReturnType<typeof useLoginGuardianChangeRecordInfoQuery>;
+export type LoginGuardianChangeRecordInfoLazyQueryHookResult = ReturnType<typeof useLoginGuardianChangeRecordInfoLazyQuery>;
+export type LoginGuardianChangeRecordInfoQueryResult = Apollo.QueryResult<LoginGuardianChangeRecordInfoQuery, LoginGuardianChangeRecordInfoQueryVariables>;

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

@@ -0,0 +1,47 @@
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {};
+export const LoginGuardianChangeRecordInfoDocument = gql `
+  query loginGuardianChangeRecordInfo($dto: GetLoginGuardianChangeRecordDto) {
+    loginGuardianChangeRecordInfo(dto: $dto) {
+      changeType
+      blockHeight
+      id
+      chainId
+      caHash
+      caAddress
+      manager
+      loginGuardian {
+        type
+        verifierId
+        identifierHash
+        salt
+        isLoginGuardian
+      }
+    }
+  }
+`;
+/**
+ * __useLoginGuardianChangeRecordInfoQuery__
+ *
+ * To run a query within a React component, call `useLoginGuardianChangeRecordInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useLoginGuardianChangeRecordInfoQuery` 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 } = useLoginGuardianChangeRecordInfoQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export function useLoginGuardianChangeRecordInfoQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(LoginGuardianChangeRecordInfoDocument, options);
+}
+export function useLoginGuardianChangeRecordInfoLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(LoginGuardianChangeRecordInfoDocument, options);
+}

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

@@ -0,0 +1,50 @@
+import * as Types from '../types.js';
+import * as Apollo from '@apollo/client';
+export type LoginGuardianInfoQueryVariables = Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetLoginGuardianInfoDto>;
+}>;
+export type LoginGuardianInfoQuery = {
+    __typename?: 'Query';
+    loginGuardianInfo?: Array<{
+        __typename?: 'LoginGuardianDto';
+        id?: string | null;
+        chainId?: string | null;
+        caHash?: string | null;
+        caAddress?: string | null;
+        manager?: string | null;
+        loginGuardian?: {
+            __typename?: 'GuardianDto';
+            type: number;
+            verifierId?: string | null;
+            identifierHash?: string | null;
+            salt?: string | null;
+            isLoginGuardian: boolean;
+        } | null;
+    } | null> | null;
+};
+export declare const LoginGuardianInfoDocument: Apollo.DocumentNode;
+/**
+ * __useLoginGuardianInfoQuery__
+ *
+ * To run a query within a React component, call `useLoginGuardianInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useLoginGuardianInfoQuery` 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 } = useLoginGuardianInfoQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export declare function useLoginGuardianInfoQuery(baseOptions?: Apollo.QueryHookOptions<LoginGuardianInfoQuery, LoginGuardianInfoQueryVariables>): Apollo.QueryResult<LoginGuardianInfoQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetLoginGuardianInfoDto> | undefined;
+}>>;
+export declare function useLoginGuardianInfoLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<LoginGuardianInfoQuery, LoginGuardianInfoQueryVariables>): Apollo.LazyQueryResultTuple<LoginGuardianInfoQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetLoginGuardianInfoDto> | undefined;
+}>>;
+export type LoginGuardianInfoQueryHookResult = ReturnType<typeof useLoginGuardianInfoQuery>;
+export type LoginGuardianInfoLazyQueryHookResult = ReturnType<typeof useLoginGuardianInfoLazyQuery>;
+export type LoginGuardianInfoQueryResult = Apollo.QueryResult<LoginGuardianInfoQuery, LoginGuardianInfoQueryVariables>;

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

@@ -0,0 +1,45 @@
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {};
+export const LoginGuardianInfoDocument = gql `
+  query loginGuardianInfo($dto: GetLoginGuardianInfoDto) {
+    loginGuardianInfo(dto: $dto) {
+      id
+      chainId
+      caHash
+      caAddress
+      manager
+      loginGuardian {
+        type
+        verifierId
+        identifierHash
+        salt
+        isLoginGuardian
+      }
+    }
+  }
+`;
+/**
+ * __useLoginGuardianInfoQuery__
+ *
+ * To run a query within a React component, call `useLoginGuardianInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useLoginGuardianInfoQuery` 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 } = useLoginGuardianInfoQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export function useLoginGuardianInfoQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(LoginGuardianInfoDocument, options);
+}
+export function useLoginGuardianInfoLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(LoginGuardianInfoDocument, options);
+}

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

@@ -0,0 +1,38 @@
+import * as Types from '../types.js';
+import * as Apollo from '@apollo/client';
+export type SyncStateQueryVariables = Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetSyncStateDto>;
+}>;
+export type SyncStateQuery = {
+    __typename?: 'Query';
+    syncState?: {
+        __typename?: 'SyncStateDto';
+        confirmedBlockHeight: number;
+    } | null;
+};
+export declare const SyncStateDocument: Apollo.DocumentNode;
+/**
+ * __useSyncStateQuery__
+ *
+ * To run a query within a React component, call `useSyncStateQuery` and pass it any options that fit your needs.
+ * When your component renders, `useSyncStateQuery` 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 } = useSyncStateQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export declare function useSyncStateQuery(baseOptions?: Apollo.QueryHookOptions<SyncStateQuery, SyncStateQueryVariables>): Apollo.QueryResult<SyncStateQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetSyncStateDto> | undefined;
+}>>;
+export declare function useSyncStateLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SyncStateQuery, SyncStateQueryVariables>): Apollo.LazyQueryResultTuple<SyncStateQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetSyncStateDto> | undefined;
+}>>;
+export type SyncStateQueryHookResult = ReturnType<typeof useSyncStateQuery>;
+export type SyncStateLazyQueryHookResult = ReturnType<typeof useSyncStateLazyQuery>;
+export type SyncStateQueryResult = Apollo.QueryResult<SyncStateQuery, SyncStateQueryVariables>;

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

@@ -0,0 +1,34 @@
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {};
+export const SyncStateDocument = gql `
+  query syncState($dto: GetSyncStateDto) {
+    syncState(dto: $dto) {
+      confirmedBlockHeight
+    }
+  }
+`;
+/**
+ * __useSyncStateQuery__
+ *
+ * To run a query within a React component, call `useSyncStateQuery` and pass it any options that fit your needs.
+ * When your component renders, `useSyncStateQuery` 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 } = useSyncStateQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export function useSyncStateQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(SyncStateDocument, options);
+}
+export function useSyncStateLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(SyncStateDocument, options);
+}

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

@@ -0,0 +1,51 @@
+import * as Types from '../types.js';
+import * as Apollo from '@apollo/client';
+export type TokenInfoQueryVariables = Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetTokenInfoDto>;
+}>;
+export type TokenInfoQuery = {
+    __typename?: 'Query';
+    tokenInfo?: Array<{
+        __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;
+};
+export declare const TokenInfoDocument: Apollo.DocumentNode;
+/**
+ * __useTokenInfoQuery__
+ *
+ * To run a query within a React component, call `useTokenInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useTokenInfoQuery` 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 } = useTokenInfoQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export declare function useTokenInfoQuery(baseOptions?: Apollo.QueryHookOptions<TokenInfoQuery, TokenInfoQueryVariables>): Apollo.QueryResult<TokenInfoQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetTokenInfoDto> | undefined;
+}>>;
+export declare function useTokenInfoLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TokenInfoQuery, TokenInfoQueryVariables>): Apollo.LazyQueryResultTuple<TokenInfoQuery, Types.Exact<{
+    dto?: Types.InputMaybe<Types.GetTokenInfoDto> | undefined;
+}>>;
+export type TokenInfoQueryHookResult = ReturnType<typeof useTokenInfoQuery>;
+export type TokenInfoLazyQueryHookResult = ReturnType<typeof useTokenInfoLazyQuery>;
+export type TokenInfoQueryResult = Apollo.QueryResult<TokenInfoQuery, TokenInfoQueryVariables>;

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

@@ -0,0 +1,47 @@
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+const defaultOptions = {};
+export const TokenInfoDocument = gql `
+  query tokenInfo($dto: GetTokenInfoDto) {
+    tokenInfo(dto: $dto) {
+      id
+      chainId
+      blockHash
+      blockHeight
+      previousBlockHash
+      symbol
+      type
+      tokenContractAddress
+      decimals
+      totalSupply
+      tokenName
+      issuer
+      isBurnable
+      issueChainId
+    }
+  }
+`;
+/**
+ * __useTokenInfoQuery__
+ *
+ * To run a query within a React component, call `useTokenInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useTokenInfoQuery` 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 } = useTokenInfoQuery({
+ *   variables: {
+ *      dto: // value for 'dto'
+ *   },
+ * });
+ */
+export function useTokenInfoQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useQuery(TokenInfoDocument, options);
+}
+export function useTokenInfoLazyQuery(baseOptions) {
+    const options = Object.assign(Object.assign({}, defaultOptions), baseOptions);
+    return Apollo.useLazyQuery(TokenInfoDocument, options);
+}