Error: The `WatermarkSheetsFolios` association is not defined on `WatermarkSheets`. Valid associations are: Facts

CORE/src/ORM/Table.php:905
Cake\ORM\Table->getAssociation CORE/src/ORM/EagerLoader.php:489
Cake\ORM\EagerLoader->_normalizeContain CORE/src/ORM/EagerLoader.php:310
Cake\ORM\EagerLoader->normalized CORE/src/ORM/EagerLoader.php:445
Cake\ORM\EagerLoader->attachableAssociations CORE/src/ORM/EagerLoader.php:416
Cake\ORM\EagerLoader->attachAssociations CORE/src/ORM/Query.php:1177
Cake\ORM\Query->_transformQuery CORE/src/ORM/Query.php:1127
Cake\ORM\Query->sql CORE/src/Database/Driver/Mysql.php:200
Cake\Database\Driver\Mysql->prepare CORE/src/Database/Connection.php:280
Cake\Database\Connection->Cake\Database\{closure} CORE/src/Core/Retry/CommandRetry.php:70
Cake\Core\Retry\CommandRetry->run CORE/src/Database/Connection.php:279
Cake\Database\Connection->prepare CORE/src/Database/Connection.php:335
Cake\Database\Connection->Cake\Database\{closure} CORE/src/Core/Retry/CommandRetry.php:70
Cake\Core\Retry\CommandRetry->run CORE/src/Database/Connection.php:334
Cake\Database\Connection->run CORE/src/Database/Query.php:250
Cake\Database\Query->execute CORE/src/ORM/Query.php:1148
Cake\ORM\Query->_execute CORE/src/Datasource/QueryTrait.php:287
Cake\ORM\Query->_all CORE/src/ORM/Query.php:1096
Cake\ORM\Query->all CORE/src/Datasource/QueryTrait.php:494
Cake\ORM\Query->first CORE/src/Datasource/QueryTrait.php:505
Cake\ORM\Query->firstOrFail CORE/src/ORM/Table.php:1541
Cake\ORM\Table->get APP/Controller/WatermarkSheetsController.php:35
App\Controller\WatermarkSheetsController->view CORE/src/Controller/Controller.php:539
Cake\Controller\Controller->invokeAction CORE/src/Controller/ControllerFactory.php:140
Cake\Controller\ControllerFactory->handle CORE/src/Controller/ControllerFactory.php:115
Cake\Controller\ControllerFactory->invoke CORE/src/Http/BaseApplication.php:317
Cake\Http\BaseApplication->handle CORE/src/Http/Runner.php:77
Cake\Http\Runner->handle ROOT/vendor/cakephp/authentication/src/Middleware/AuthenticationMiddleware.php:124
Authentication\Middleware\AuthenticationMiddleware->process CORE/src/Http/Runner.php:73
Cake\Http\Runner->handle CORE/src/Routing/Middleware/RoutingMiddleware.php:161
Cake\Routing\Middleware\RoutingMiddleware->process CORE/src/Http/Runner.php:73
Cake\Http\Runner->handle CORE/src/Http/Runner.php:58
Cake\Http\Runner->run CORE/src/Http/Server.php:90
Cake\Http\Server->run ROOT/webroot/index.php:40

CORE/src/ORM/Table.php Toggle Arguments

	$message = "The `{$name}` association is not defined on `{$this->getAlias()}`.";
	`if ($assocations) {`
	`$message .= "\nValid associations are: " . implode(', ', $assocations);`
	`}`
	`throw new InvalidArgumentException($message);`
	`}`

	`return $association;`
	`}`

If you want to customize this error message, create templates/Error/error500.php

	`*/`
	`protected function _normalizeContain(Table $parent, string $alias, array $options, array $paths): EagerLoadable`
	`{`
	`$defaults = $this->_containOptions;`
	`$instance = $parent->getAssociation($alias);`

	`$paths += ['aliasPath' => '', 'propertyPath' => '', 'root' => $alias];`
	`$paths['aliasPath'] .= '.' . $alias;`

	`if (!empty($options['instance'])) {`
	`$contain = $this->_containments;`
	`break;`
	`}`
	`$contain[$alias] = $this->_normalizeContain(`
	`$repository,`
	`$alias,`
	`$options,`
	`['root' => null]`

	`* @return array<\Cake\ORM\EagerLoadable>`
	`*/`
	`public function attachableAssociations(Table $repository): array`
	`{`
	`$contain = $this->normalized($repository);`
	`$matching = $this->_matching ? $this->_matching->normalized($repository) : [];`
	`$this->_fixStrategies();`
	`$this->_loadExternal = [];`

	`if (empty($this->_containments) && $this->_matching === null) {`
	`return;`
	`}`

	`$attachable = $this->attachableAssociations($repository);`
	`$processed = [];`
	`do {`
	`foreach ($attachable as $alias => $loadable) {`
	`$config = $loadable->getConfig() + [`

	`if (empty($this->_parts['from'])) {`
	`$this->from([$repository->getAlias() => $repository->getTable()]);`
	`}`
	`$this->_addDefaultFields();`
	`$this->getEagerLoader()->attachAssociations($this, $repository, !$this->_hasFields);`
	`$this->_addDefaultSelectTypes();`
	`}`

	`/**`

	`public function sql(?ValueBinder $binder = null): string`
	`{`
	`$this->triggerBeforeFind();`

	`$this->_transformQuery();`

	`return parent::sql($binder);`
	`}`

	`/**`
	`* @psalm-suppress PossiblyInvalidMethodCall`
	`* @psalm-suppress PossiblyInvalidArgument`
	`*/`
	`$statement = $this->_connection->prepare($isObject ? $query->sql() : $query);`
	`$result = new MysqlStatement($statement, $this);`
	`/** @psalm-suppress PossiblyInvalidMethodCall */`
	`if ($isObject && $query->isBufferedResultsEnabled() === false) {`
	`$result->bufferResults(false);`

	`*/`
	`public function prepare($query): StatementInterface`
	`{`
	`return $this->getDisconnectRetry()->run(function () use ($query) {`
	`$statement = $this->_driver->prepare($query);`

	`if ($this->_logQueries) {`
	`$statement = $this->_newLogger($statement);`
	`}`

	`{`
	`$this->numRetries = 0;`
	`while (true) {`
	`try {`
	`return $action();`
	`} catch (Exception $e) {`
	`if (`
	`$this->numRetries < $this->maxRetries &&`
	`$this->strategy->shouldRetry($e, $this->numRetries)`

	`* @return \Cake\Database\StatementInterface`
	`*/`
	`public function prepare($query): StatementInterface`
	`{`
	`return $this->getDisconnectRetry()->run(function () use ($query) {`
	`$statement = $this->_driver->prepare($query);`

	`if ($this->_logQueries) {`
	`$statement = $this->_newLogger($statement);`

	`*/`
	`public function run(Query $query): StatementInterface`
	`{`
	`return $this->getDisconnectRetry()->run(function () use ($query) {`
	`$statement = $this->prepare($query);`
	`$query->getValueBinder()->attachTo($statement);`
	`$statement->execute();`

	`return $statement;`

	`* @return \Cake\Database\StatementInterface`
	`*/`
	`public function execute(): StatementInterface`
	`{`
	`$statement = $this->_connection->run($this);`
	`$this->_iterator = $this->_decorateStatement($statement);`
	`$this->_dirty = false;`

	`return $this->_iterator;`


	`return new $decorator($this->_results);`
	`}`

	`$statement = $this->getEagerLoader()->loadExternal($this, $this->execute());`

	`return new ResultSet($this, $statement);`
	`}`

	`if ($this->_cache) {`
	`$results = $this->_cache->fetch($this);`
	`}`
	`if ($results === null) {`
	`$results = $this->_decorateResults($this->_execute());`
	`if ($this->_cache) {`
	`$this->_cache->store($this, $results);`
	`}`
	`}`

	`'You cannot call all() on a non-select query. Use execute() instead.'`
	`);`
	`}`

	`return $this->_all();`
	`}`

	`/**`
	`* Trigger the beforeFind event on the query's repository object.`

	`if ($this->_dirty) {`
	`$this->limit(1);`
	`}`

	`return $this->all()->first();`
	`}`

	`/**`
	`* Get the first result from the executing query or raise an exception.`

	`* @return \Cake\Datasource\EntityInterface\|array The first result from the ResultSet.`
	`*/`
	`public function firstOrFail()`
	`{`
	`$entity = $this->first();`
	`if (!$entity) {`
	`$table = $this->getRepository();`
	`throw new RecordNotFoundException(sprintf(`
	`'Record not found in table "%s"',`

	`$query->cache($cacheKey, $cacheConfig);`
	`}`

	`/** @psalm-suppress InvalidReturnStatement */`
	`return $query->firstOrFail();`
	`}`

	`/**`
	`* Handles the logic executing of a worker inside a transaction.`

	`* @throws \Cake\Datasource\Exception\RecordNotFoundException When record not found.`
	`*/`
	`public function view($id = null)`
	`{`
	`$watermarkSheet = $this->WatermarkSheets->get($id, [`
	`'contain' => ['Facts', 'WatermarkSheetsFolios', 'WatermarkFolios'],`
	`]);`

	`$this->set(compact('watermarkSheet'));`

	* @throws \UnexpectedValueException If return value of action is not `null` or `ResponseInterface` instance.
	`*/`
	`public function invokeAction(Closure $action, array $args): void`
	`{`
	`$result = $action(...$args);`
	`if ($result !== null && !$result instanceof ResponseInterface) {`
	`throw new UnexpectedValueException(sprintf(`
	`'Controller actions can only return ResponseInterface instance or null. '`
	`. 'Got %s instead.',`

	`$args = $this->getActionArgs(`
	`$action,`
	`array_values((array)$controller->getRequest()->getParam('pass'))`
	`);`
	`$controller->invokeAction($action, $args);`

	`$result = $controller->shutdownProcess();`
	`if ($result instanceof ResponseInterface) {`
	`return $result;`


	`return $runner->run($middlewareQueue, $controller->getRequest(), $this);`
	`}`

	`return $this->handle($controller->getRequest());`
	`}`

	`/**`
	`* Invoke the action.`

	`}`

	`$controller = $this->controllerFactory->create($request);`

	`return $this->controllerFactory->invoke($controller);`
	`}`
	`}`

	`return $middleware->process($request, $this);`
	`}`

	`if ($this->fallbackHandler) {`
	`return $this->fallbackHandler->handle($request);`
	`}`

	`$response = new Response([`
	`'body' => 'Middleware queue was exhausted without returning a response '`

	`$request = $request->withAttribute('authentication', $service);`
	`$request = $request->withAttribute('authenticationResult', $result);`

	`try {`
	`$response = $handler->handle($request);`
	`$authenticator = $service->getAuthenticationProvider();`

	`if ($authenticator !== null && !$authenticator instanceof StatelessInterface) {`
	`$return = $service->persistIdentity($request, $response, $result->getData());`

	`if ($this->queue->valid()) {`
	`$middleware = $this->queue->current();`
	`$this->queue->next();`

	`return $middleware->process($request, $this);`
	`}`

	`if ($this->fallbackHandler) {`
	`return $this->fallbackHandler->handle($request);`

	`);`
	`}`
	`$matching = Router::getRouteCollection()->getMiddleware($middleware);`
	`if (!$matching) {`
	`return $handler->handle($request);`
	`}`

	`$middleware = new MiddlewareQueue($matching);`
	`$runner = new Runner();`

	`$this->queue = $queue;`
	`$this->queue->rewind();`
	`$this->fallbackHandler = $fallbackHandler;`

	`return $this->handle($request);`
	`}`

	`/**`
	`* Handle incoming server request and return a response.`

	`}`

	`$this->dispatchEvent('Server.buildMiddleware', ['middleware' => $middleware]);`

	`$response = $this->runner->run($middleware, $request, $this->app);`

	`if ($request instanceof ServerRequest) {`
	`$request->getSession()->close();`
	`}`

	`// Bind your application to the server.`
	`$server = new Server(new Application(dirname(__DIR__) . '/config'));`

	`// Run the request/response through the application and emit the response.`
	`$server->emit($server->run());`