private final String output;

    /**
     * Array of new input character sequences for update operations.
     * When not null, indicates this item has pending updates.
     */
    private String[] newInputs;

    /**
     * The new output character sequence for update operations.
     * When not null, indicates this item has pending updates.
     */
    private String newOutput;

    /**

  private @Nullable ByteBuffer scratch;

  /** Updates this hasher with the given byte. */
  protected abstract void update(byte b);

  /** Updates this hasher with the given bytes. */
  protected void update(byte[] b) {
    update(b, 0, b.length);
  }

  /** Updates this hasher with {@code len} bytes starting at {@code off} in the given buffer. */
  protected void update(byte[] b, int off, int len) {

            Hexdump.hexdump(log, input, offset, Math.min(len, 256));
            log.flush();
        }
        if (len == 0) {
            return; /* CRITICAL */
        }
        digest.update(input, offset, len);
        updates++;
    }

    /**
     * Computes and returns the message digest.
     *
     * @return the computed digest bytes
     */

        return duplicateHostBhv.selectByPK(id);
    }

    /**
     * Stores (inserts or updates) a duplicate host configuration.
     *
     * <p>This method immediately refreshes the index to ensure the change is visible.
     * If the configuration already exists (based on ID), it will be updated;
     * otherwise, a new configuration will be created.</p>
     *

        });
        return redirect(getClass());
    }

    /**
     * Updates an existing user.
     *
     * @param form the edit form containing the updated user data
     * @return HTML response redirecting to the list page after update
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse update(final EditForm form) {
        verifyCrudMode(form.crudMode, CrudMode.EDIT, this::asListHtml);

	}

	rows, err := gorm.G[User](DB).Where("id = ?", user.ID).Set(assocOp).Update(ctx)
	if err != nil {
		t.Fatalf("Set Update has-one create values failed: %v", err)
	}
	if rows != 0 {
		t.Fatalf("expected 0 rows affected for association-only update, got %d", rows)
	}

	var updated User
	if err := DB.Preload("NamedPet").First(&updated, user.ID).Error; err != nil {
		t.Fatalf("failed to load user: %v", err)
	}

        return context;
    }

    /**
     * Updates the preauth integrity hash with a new message.
     *
     * @param sessionId the session identifier
     * @param messageData the message data to include in hash
     * @throws CIFSException if update fails
     */
    public void updatePreauthHash(String sessionId, byte[] messageData) throws CIFSException {

        return asJson(new ApiUpdateResponse().id(relatedQuery.getId()).created(true).status(Status.OK).result());
    }

    /**
     * Updates an existing related query setting.
     *
     * @param body the related query configuration data to update
     * @return JSON response containing the updated related query ID and status
     */
    // PUT /api/admin/relatedquery/setting
    @Execute

	default:
		m = cache.iamUsersMap
	}
	err := store.loadUser(ctx, accessKey, userType, m)

	if err == errNoSuchUser {
		// User was deleted - we update the cache.
		delete(m, accessKey)

		// Since cache was updated, we update the timestamp.
		defer func() {
			cache.updatedAt = time.Now()
		}()

		// 1. Start with updating user-group memberships

	}
}

// updateCacheEntry will update a cache.
// Returns the updated status.
func (b *bucketMetacache) updateCacheEntry(update metacache) (metacache, error) {
	b.mu.Lock()
	defer b.mu.Unlock()
	existing, ok := b.caches[update.id]
	if !ok {
		return update, errFileNotFound
	}
	existing.update(update)
	b.caches[update.id] = existing
	b.updated = true
	return existing, nil
}