text: import TokenId from "./TokenId.js";
  import AccountId from "../account/AccountId.js";
  import Transaction, {
      TRANSACTION_REGISTRY,
  } from "../transaction/Transaction.js";
  
  /**
   * @namespace proto
   * @typedef {import("@hashgraph/proto").ITransaction} proto.ITransaction
   * @typedef {import("@hashgraph/proto").ISignedTransaction} proto.ISignedTransaction
   * @typedef {import("@hashgraph/proto").TransactionBody} proto.TransactionBody
   * @typedef {import("@hashgraph/proto").ITransactionBody} proto.ITransactionBody
   * @typedef {import("@hashgraph/proto").ITransactionResponse} proto.ITransactionResponse
   * @typedef {import("@hashgraph/proto").ITokenGrantKycTransactionBody} proto.ITokenGrantKycTransactionBody
   * @typedef {import("@hashgraph/proto").ITokenID} proto.ITokenID
   */
  
  /**
   * @typedef {import("../channel/Channel.js").default} Channel
   * @typedef {import("../transaction/TransactionId.js").default} TransactionId
   */
  
  /**
   * GrantKyc a new Hedera™ crypto-currency token.
   */
  export default class TokenGrantKycTransaction extends Transaction {
      /**
       * @param {object} [props]
       * @param {TokenId | string} [props.tokenId]
       * @param {AccountId | string} [props.accountId]
       */
      constructor(props = {}) {
          super();
  
          /**
           * @private
           * @type {?TokenId}
           */
          this._tokenId = null;
  
          /**
           * @private
           * @type {?AccountId}
           */
          this._accountId = null;
  
          if (props.tokenId != null) {
              this.setTokenId(props.tokenId);
          }
  
          if (props.accountId != null) {
              this.setAccountId(props.accountId);
          }
      }
  
      /**
       * @internal
       * @param {proto.ITransaction[]} transactions
       * @param {proto.ISignedTransaction[]} signedTransactions
       * @param {TransactionId[]} transactionIds
       * @param {AccountId[]} nodeIds
       * @param {proto.ITransactionBody[]} bodies
       * @returns {TokenGrantKycTransaction}
       */
      static _fromProtobuf(
          transactions,
          signedTransactions,
          transactionIds,
          nodeIds,
          bodies
      ) {
          const body = bodies[0];
          const grantKycToken = /** @type {proto.ITokenGrantKycTransactionBody} */ (body.tokenGrantKyc);
  
          return Transaction._fromProtobufTransactions(
              new TokenGrantKycTransaction({
                  tokenId:
                      grantKycToken.token != null
                          ? TokenId._fromProtobuf(grantKycToken.token)
                          : undefined,
                  accountId:
                      grantKycToken.account != null
                          ? AccountId._fromProtobuf(grantKycToken.account)
                          : undefined,
              }),
              transactions,
              signedTransactions,
              transactionIds,
              nodeIds,
              bodies
          );
      }
  
      /**
       * @returns {?TokenId}
       */
      get tokenId() {
          return this._tokenId;
      }
  
      /**
       * @param {TokenId | string} tokenId
       * @returns {this}
       */
      setTokenId(tokenId) {
          this._requireNotFrozen();
          this._tokenId =
              tokenId instanceof TokenId ? tokenId : TokenId.fromString(tokenId);
  
          return this;
      }
  
      /**
       * @returns {?AccountId}
       */
      get accountId() {
          return this._accountId;
      }
  
      /**
       * @param {AccountId | string} accountId
       * @returns {this}
       */
      setAccountId(accountId) {
          this._requireNotFrozen();
          this._accountId =
              accountId instanceof AccountId
                  ? accountId
                  : AccountId.fromString(accountId);
  
          return this;
      }
  
      /**
       * @override
       * @internal
       * @param {Channel} channel
       * @param {proto.ITransaction} request
       * @returns {Promise<proto.ITransactionResponse>}
       */
      _execute(channel, request) {
          return channel.token.grantKycToTokenAccount(request);
      }
  
      /**
       * @override
       * @protected
       * @returns {NonNullable<proto.TransactionBody["data"]>}
       */
      _getTransactionDataCase() {
          return "tokenGrantKyc";
      }
  
      /**
       * @override
       * @protected
       * @returns {proto.ITokenGrantKycTransactionBody}
       */
      _makeTransactionData() {
          return {
              token: this._tokenId != null ? this._tokenId._toProtobuf() : null,
              account:
                  this._accountId != null ? this._accountId._toProtobuf() : null,
          };
      }
  }
  
  TRANSACTION_REGISTRY.set(
      "tokenGrantKyc",
      // eslint-disable-next-line @typescript-eslint/unbound-method
      TokenGrantKycTransaction._fromProtobuf
  );
  