@crawlee/core 3.13.3-beta.11 → 3.13.3-beta.13

package/storages/request_list.d.ts

@@ -19,7 +19,7 @@ export interface IRequestList {
      */
     isFinished(): Promise<boolean>;
     /**
-     * Resolves to `true` if the next call to {@apilink IRequestList.fetchNextRequest} function
+     * Resolves to `true` if the next call to {@link IRequestList.fetchNextRequest} function
      * would return `null`, otherwise it resolves to `false`.
      * Note that even if the list is empty, there might be some pending requests currently being processed.
      */
@@ -29,7 +29,7 @@ export interface IRequestList {
      */
     handledCount(): number;
     /**
-     * Persists the current state of the `IRequestList` into the default {@apilink KeyValueStore}.
+     * Persists the current state of the `IRequestList` into the default {@link KeyValueStore}.
      * The state is persisted automatically in regular intervals, but calling this method manually
      * is useful in cases where you want to have the most current state available after you pause
      * or stop fetching its requests. For example after you pause or abort a crawl. Or just before
@@ -37,8 +37,8 @@ export interface IRequestList {
      */
     persistState(): Promise<void>;
     /**
-     * Gets the next {@apilink Request} to process. First, the function gets a request previously reclaimed
-     * using the {@apilink RequestList.reclaimRequest} function, if there is any.
+     * Gets the next {@link Request} to process. First, the function gets a request previously reclaimed
+     * using the {@link RequestList.reclaimRequest} function, if there is any.
      * Otherwise it gets the next request from sources.
      *
      * The function's `Promise` resolves to `null` if there are no more
@@ -46,8 +46,8 @@ export interface IRequestList {
      */
     fetchNextRequest(): Promise<Request | null>;
     /**
-     * Gets the next {@apilink Request} to process. First, the function gets a request previously reclaimed
-     * using the {@apilink RequestList.reclaimRequest} function, if there is any.
+     * Gets the next {@link Request} to process. First, the function gets a request previously reclaimed
+     * using the {@link RequestList.reclaimRequest} function, if there is any.
      * Otherwise it gets the next request from sources.
      *
      * The function resolves to `null` if there are no more requests to process.
@@ -72,8 +72,8 @@ export interface IRequestList {
 }
 export interface RequestListOptions {
     /**
-     * An array of sources of URLs for the {@apilink RequestList}. It can be either an array of strings,
-     * plain objects that define at least the `url` property, or an array of {@apilink Request} instances.
+     * An array of sources of URLs for the {@link RequestList}. It can be either an array of strings,
+     * plain objects that define at least the `url` property, or an array of {@link Request} instances.
      *
      * **IMPORTANT:** The `sources` array will be consumed (left empty) after `RequestList` initializes.
      * This is a measure to prevent memory leaks in situations when millions of sources are
@@ -107,15 +107,15 @@ export interface RequestListOptions {
     sources?: RequestListSource[];
     /**
      * A function that will be called to get the sources for the `RequestList`, but only if `RequestList`
-     * was not able to fetch their persisted version (see {@apilink RequestListOptions.persistRequestsKey}).
-     * It must return an `Array` of {@apilink Request} or {@apilink RequestOptions}.
+     * was not able to fetch their persisted version (see {@link RequestListOptions.persistRequestsKey}).
+     * It must return an `Array` of {@link Request} or {@link RequestOptions}.
      *
      * This is very useful in a scenario when getting the sources is a resource intensive or time consuming
      * task, such as fetching URLs from multiple sitemaps or parsing URLs from large datasets. Using the
      * `sourcesFunction` in combination with `persistStateKey` and `persistRequestsKey` will allow you to
      * fetch and parse those URLs only once, saving valuable time when your crawler migrates or restarts.
      *
-     * If both {@apilink RequestListOptions.sources} and {@apilink RequestListOptions.sourcesFunction} are provided,
+     * If both {@link RequestListOptions.sources} and {@link RequestListOptions.sourcesFunction} are provided,
      * the sources returned by the function will be added after the `sources`.
      *
      * **Example:**
@@ -162,12 +162,12 @@ export interface RequestListOptions {
     persistStateKey?: string;
     /**
      * Identifies the key in the default key-value store under which the `RequestList` persists its
-     * Requests during the {@apilink RequestList.initialize} call.
+     * Requests during the {@link RequestList.initialize} call.
      * This is necessary if `persistStateKey` is set and the source URLs might potentially change,
      * to ensure consistency of the source URLs and state object. However, it comes with some
      * storage and performance overheads.
      *
-     * If `persistRequestsKey` is not set, {@apilink RequestList.initialize} will always fetch the sources
+     * If `persistRequestsKey` is not set, {@link RequestList.initialize} will always fetch the sources
      * from their origin, check that they are consistent with the restored state (if any)
      * and throw an error if they are not.
      */
@@ -193,7 +193,7 @@ export interface RequestListOptions {
     state?: RequestListState;
     /**
      * By default, `RequestList` will deduplicate the provided URLs. Default deduplication is based
-     * on the `uniqueKey` property of passed source {@apilink Request} objects.
+     * on the `uniqueKey` property of passed source {@link Request} objects.
      *
      * If the property is not present, it is generated by normalizing the URL. If present, it is kept intact.
      * In any case, only one request per `uniqueKey` is added to the `RequestList` resulting in removal
@@ -213,19 +213,19 @@ export interface RequestListOptions {
 /**
  * Represents a static list of URLs to crawl.
  * The URLs can be provided either in code or parsed from a text file hosted on the web.
- * `RequestList` is used by {@apilink BasicCrawler}, {@apilink CheerioCrawler}, {@apilink PuppeteerCrawler}
- * and {@apilink PlaywrightCrawler} as a source of URLs to crawl.
+ * `RequestList` is used by {@link BasicCrawler}, {@link CheerioCrawler}, {@link PuppeteerCrawler}
+ * and {@link PlaywrightCrawler} as a source of URLs to crawl.
  *
- * Each URL is represented using an instance of the {@apilink Request} class.
+ * Each URL is represented using an instance of the {@link Request} class.
  * The list can only contain unique URLs. More precisely, it can only contain `Request` instances
  * with distinct `uniqueKey` properties. By default, `uniqueKey` is generated from the URL, but it can also be overridden.
- * To add a single URL to the list multiple times, corresponding {@apilink Request} objects will need to have different
+ * To add a single URL to the list multiple times, corresponding {@link Request} objects will need to have different
  * `uniqueKey` properties. You can use the `keepDuplicateUrls` option to do this for you when initializing the
  * `RequestList` from sources.
  *
- * `RequestList` doesn't have a public constructor, you need to create it with the asynchronous {@apilink RequestList.open} function. After
+ * `RequestList` doesn't have a public constructor, you need to create it with the asynchronous {@link RequestList.open} function. After
  * the request list is created, no more URLs can be added to it.
- * Unlike {@apilink RequestQueue}, `RequestList` is static but it can contain even millions of URLs.
+ * Unlike {@link RequestQueue}, `RequestList` is static but it can contain even millions of URLs.
  * > Note that `RequestList` can be used together with `RequestQueue` by the same crawler.
  * > In such cases, each request from `RequestList` is enqueued into `RequestQueue` first and then consumed from the latter.
  * > This is necessary to avoid the same URL being processed more than once (from the list first and then possibly from the queue).
@@ -234,9 +234,9 @@ export interface RequestListOptions {
  *
  * `RequestList` has an internal state where it stores information about which requests were already handled,
  * which are in progress and which were reclaimed. The state may be automatically persisted to the default
- * {@apilink KeyValueStore} by setting the `persistStateKey` option so that if the Node.js process is restarted,
+ * {@link KeyValueStore} by setting the `persistStateKey` option so that if the Node.js process is restarted,
  * the crawling can continue where it left off. The automated persisting is launched upon receiving the `persistState`
- * event that is periodically emitted by {@apilink EventManager}.
+ * event that is periodically emitted by {@link EventManager}.
  *
  * The internal state is closely tied to the provided sources (URLs). If the sources change on crawler restart, the state will become corrupted and
  * `RequestList` will raise an exception. This typically happens when the sources is a list of URLs downloaded from the web.
@@ -425,14 +425,14 @@ export declare class RequestList implements IRequestList {
     handledCount(): number;
     /**
      * Opens a request list and returns a promise resolving to an instance
-     * of the {@apilink RequestList} class that is already initialized.
+     * of the {@link RequestList} class that is already initialized.
      *
-     * {@apilink RequestList} represents a list of URLs to crawl, which is always stored in memory.
+     * {@link RequestList} represents a list of URLs to crawl, which is always stored in memory.
      * To enable picking up where left off after a process restart, the request list sources
      * are persisted to the key-value store at initialization of the list. Then, while crawling,
      * a small state object is regularly persisted to keep track of the crawling status.
      *
-     * For more details and code examples, see the {@apilink RequestList} class.
+     * For more details and code examples, see the {@link RequestList} class.
      *
      * **Example usage:**
      *
@@ -458,23 +458,23 @@ export declare class RequestList implements IRequestList {
      *   If `null`, the list will not be persisted and will only be stored in memory. Process restart
      *   will then cause the list to be crawled again from the beginning. We suggest always using a name.
      * @param [sources]
-     *  An array of sources of URLs for the {@apilink RequestList}. It can be either an array of strings,
-     *  plain objects that define at least the `url` property, or an array of {@apilink Request} instances.
+     *  An array of sources of URLs for the {@link RequestList}. It can be either an array of strings,
+     *  plain objects that define at least the `url` property, or an array of {@link Request} instances.
      *
-     *  **IMPORTANT:** The `sources` array will be consumed (left empty) after {@apilink RequestList} initializes.
+     *  **IMPORTANT:** The `sources` array will be consumed (left empty) after {@link RequestList} initializes.
      *  This is a measure to prevent memory leaks in situations when millions of sources are
      *  added.
      *
      *  Additionally, the `requestsFromUrl` property may be used instead of `url`,
-     *  which will instruct {@apilink RequestList} to download the source URLs from a given remote location.
+     *  which will instruct {@link RequestList} to download the source URLs from a given remote location.
      *  The URLs will be parsed from the received response. In this case you can limit the URLs
      *  using `regex` parameter containing regular expression pattern for URLs to be included.
      *
-     *  For details, see the {@apilink RequestListOptions.sources}
+     *  For details, see the {@link RequestListOptions.sources}
      * @param [options]
-     *   The {@apilink RequestList} options. Note that the `listName` parameter supersedes
-     *   the {@apilink RequestListOptions.persistStateKey} and {@apilink RequestListOptions.persistRequestsKey}
-     *   options and the `sources` parameter supersedes the {@apilink RequestListOptions.sources} option.
+     *   The {@link RequestList} options. Note that the `listName` parameter supersedes
+     *   the {@link RequestListOptions.persistStateKey} and {@link RequestListOptions.persistRequestsKey}
+     *   options and the `sources` parameter supersedes the {@link RequestListOptions.sources} option.
      */
     static open(listNameOrOptions: string | null | RequestListOptions, sources?: RequestListSource[], options?: RequestListOptions): Promise<RequestList>;
     /**
@@ -483,8 +483,8 @@ export declare class RequestList implements IRequestList {
     private _downloadListOfUrls;
 }
 /**
- * Represents state of a {@apilink RequestList}. It can be used to resume a {@apilink RequestList} which has been previously processed.
- * You can obtain the state by calling {@apilink RequestList.getState} and receive an object with
+ * Represents state of a {@link RequestList}. It can be used to resume a {@link RequestList} which has been previously processed.
+ * You can obtain the state by calling {@link RequestList.getState} and receive an object with
  * the following structure:
  *
  * ```

package/storages/request_list.js

@@ -18,19 +18,19 @@ const CONTENT_TYPE_BINARY = 'application/octet-stream';
 /**
  * Represents a static list of URLs to crawl.
  * The URLs can be provided either in code or parsed from a text file hosted on the web.
- * `RequestList` is used by {@apilink BasicCrawler}, {@apilink CheerioCrawler}, {@apilink PuppeteerCrawler}
- * and {@apilink PlaywrightCrawler} as a source of URLs to crawl.
+ * `RequestList` is used by {@link BasicCrawler}, {@link CheerioCrawler}, {@link PuppeteerCrawler}
+ * and {@link PlaywrightCrawler} as a source of URLs to crawl.
  *
- * Each URL is represented using an instance of the {@apilink Request} class.
+ * Each URL is represented using an instance of the {@link Request} class.
  * The list can only contain unique URLs. More precisely, it can only contain `Request` instances
  * with distinct `uniqueKey` properties. By default, `uniqueKey` is generated from the URL, but it can also be overridden.
- * To add a single URL to the list multiple times, corresponding {@apilink Request} objects will need to have different
+ * To add a single URL to the list multiple times, corresponding {@link Request} objects will need to have different
  * `uniqueKey` properties. You can use the `keepDuplicateUrls` option to do this for you when initializing the
  * `RequestList` from sources.
  *
- * `RequestList` doesn't have a public constructor, you need to create it with the asynchronous {@apilink RequestList.open} function. After
+ * `RequestList` doesn't have a public constructor, you need to create it with the asynchronous {@link RequestList.open} function. After
  * the request list is created, no more URLs can be added to it.
- * Unlike {@apilink RequestQueue}, `RequestList` is static but it can contain even millions of URLs.
+ * Unlike {@link RequestQueue}, `RequestList` is static but it can contain even millions of URLs.
  * > Note that `RequestList` can be used together with `RequestQueue` by the same crawler.
  * > In such cases, each request from `RequestList` is enqueued into `RequestQueue` first and then consumed from the latter.
  * > This is necessary to avoid the same URL being processed more than once (from the list first and then possibly from the queue).
@@ -39,9 +39,9 @@ const CONTENT_TYPE_BINARY = 'application/octet-stream';
  *
  * `RequestList` has an internal state where it stores information about which requests were already handled,
  * which are in progress and which were reclaimed. The state may be automatically persisted to the default
- * {@apilink KeyValueStore} by setting the `persistStateKey` option so that if the Node.js process is restarted,
+ * {@link KeyValueStore} by setting the `persistStateKey` option so that if the Node.js process is restarted,
  * the crawling can continue where it left off. The automated persisting is launched upon receiving the `persistState`
- * event that is periodically emitted by {@apilink EventManager}.
+ * event that is periodically emitted by {@link EventManager}.
  *
  * The internal state is closely tied to the provided sources (URLs). If the sources change on crawler restart, the state will become corrupted and
  * `RequestList` will raise an exception. This typically happens when the sources is a list of URLs downloaded from the web.
@@ -657,14 +657,14 @@ class RequestList {
     }
     /**
      * Opens a request list and returns a promise resolving to an instance
-     * of the {@apilink RequestList} class that is already initialized.
+     * of the {@link RequestList} class that is already initialized.
      *
-     * {@apilink RequestList} represents a list of URLs to crawl, which is always stored in memory.
+     * {@link RequestList} represents a list of URLs to crawl, which is always stored in memory.
      * To enable picking up where left off after a process restart, the request list sources
      * are persisted to the key-value store at initialization of the list. Then, while crawling,
      * a small state object is regularly persisted to keep track of the crawling status.
      *
-     * For more details and code examples, see the {@apilink RequestList} class.
+     * For more details and code examples, see the {@link RequestList} class.
      *
      * **Example usage:**
      *
@@ -690,23 +690,23 @@ class RequestList {
      *   If `null`, the list will not be persisted and will only be stored in memory. Process restart
      *   will then cause the list to be crawled again from the beginning. We suggest always using a name.
      * @param [sources]
-     *  An array of sources of URLs for the {@apilink RequestList}. It can be either an array of strings,
-     *  plain objects that define at least the `url` property, or an array of {@apilink Request} instances.
+     *  An array of sources of URLs for the {@link RequestList}. It can be either an array of strings,
+     *  plain objects that define at least the `url` property, or an array of {@link Request} instances.
      *
-     *  **IMPORTANT:** The `sources` array will be consumed (left empty) after {@apilink RequestList} initializes.
+     *  **IMPORTANT:** The `sources` array will be consumed (left empty) after {@link RequestList} initializes.
      *  This is a measure to prevent memory leaks in situations when millions of sources are
      *  added.
      *
      *  Additionally, the `requestsFromUrl` property may be used instead of `url`,
-     *  which will instruct {@apilink RequestList} to download the source URLs from a given remote location.
+     *  which will instruct {@link RequestList} to download the source URLs from a given remote location.
      *  The URLs will be parsed from the received response. In this case you can limit the URLs
      *  using `regex` parameter containing regular expression pattern for URLs to be included.
      *
-     *  For details, see the {@apilink RequestListOptions.sources}
+     *  For details, see the {@link RequestListOptions.sources}
      * @param [options]
-     *   The {@apilink RequestList} options. Note that the `listName` parameter supersedes
-     *   the {@apilink RequestListOptions.persistStateKey} and {@apilink RequestListOptions.persistRequestsKey}
-     *   options and the `sources` parameter supersedes the {@apilink RequestListOptions.sources} option.
+     *   The {@link RequestList} options. Note that the `listName` parameter supersedes
+     *   the {@link RequestListOptions.persistStateKey} and {@link RequestListOptions.persistRequestsKey}
+     *   options and the `sources` parameter supersedes the {@link RequestListOptions.sources} option.
      */
     static async open(listNameOrOptions, sources, options = {}) {
         if (listNameOrOptions != null && typeof listNameOrOptions === 'object') {

package/storages/request_provider.d.ts

@@ -39,12 +39,12 @@ export declare abstract class RequestProvider implements IStorage {
      *
      * If a request with the same `uniqueKey` property is already present in the queue,
      * it will not be updated. You can find out whether this happened from the resulting
-     * {@apilink QueueOperationInfo} object.
+     * {@link QueueOperationInfo} object.
      *
      * To add multiple requests to the queue by extracting links from a webpage,
-     * see the {@apilink enqueueLinks} helper function.
+     * see the {@link enqueueLinks} helper function.
      *
-     * @param requestLike {@apilink Request} object or vanilla object with request data.
+     * @param requestLike {@link Request} object or vanilla object with request data.
      * Note that the function sets the `uniqueKey` and `id` fields to the passed Request.
      * @param [options] Request queue operation options.
      */
@@ -57,9 +57,9 @@ export declare abstract class RequestProvider implements IStorage {
      *
      * If a request passed in is already present due to its `uniqueKey` property being the same,
      * it will not be updated. You can find out whether this happened by finding the request in the resulting
-     * {@apilink BatchAddRequestsResult} object.
+     * {@link BatchAddRequestsResult} object.
      *
-     * @param requestsLike {@apilink Request} objects or vanilla objects with request data.
+     * @param requestsLike {@link Request} objects or vanilla objects with request data.
      * Note that the function sets the `uniqueKey` and `id` fields to the passed requests if missing.
      * @param [options] Request queue operation options.
      */
@@ -85,15 +85,15 @@ export declare abstract class RequestProvider implements IStorage {
      * Returns a next request in the queue to be processed, or `null` if there are no more pending requests.
      *
      * Once you successfully finish processing of the request, you need to call
-     * {@apilink RequestQueue.markRequestHandled}
+     * {@link RequestQueue.markRequestHandled}
      * to mark the request as handled in the queue. If there was some error in processing the request,
-     * call {@apilink RequestQueue.reclaimRequest} instead,
+     * call {@link RequestQueue.reclaimRequest} instead,
      * so that the queue will give the request to some other consumer in another call to the `fetchNextRequest` function.
      *
      * Note that the `null` return value doesn't mean the queue processing finished,
      * it means there are currently no pending requests.
      * To check whether all requests in queue were finished,
-     * use {@apilink RequestQueue.isFinished} instead.
+     * use {@link RequestQueue.isFinished} instead.
      *
      * @returns
      *   Returns the request object or `null` if there are no more pending requests.
@@ -101,24 +101,24 @@ export declare abstract class RequestProvider implements IStorage {
     abstract fetchNextRequest<T extends Dictionary = Dictionary>(options?: RequestOptions): Promise<Request<T> | null>;
     /**
      * Marks a request that was previously returned by the
-     * {@apilink RequestQueue.fetchNextRequest}
+     * {@link RequestQueue.fetchNextRequest}
      * function as handled after successful processing.
      * Handled requests will never again be returned by the `fetchNextRequest` function.
      */
     markRequestHandled(request: Request): Promise<RequestQueueOperationInfo | null>;
     /**
      * Reclaims a failed request back to the queue, so that it can be returned for processing later again
-     * by another call to {@apilink RequestQueue.fetchNextRequest}.
+     * by another call to {@link RequestQueue.fetchNextRequest}.
      * The request record in the queue is updated using the provided `request` parameter.
      * For example, this lets you store the number of retries or error messages for the request.
      */
     reclaimRequest(request: Request, options?: RequestQueueOperationOptions): Promise<RequestQueueOperationInfo | null>;
     protected abstract ensureHeadIsNonEmpty(): Promise<void>;
     /**
-     * Resolves to `true` if the next call to {@apilink RequestQueue.fetchNextRequest}
+     * Resolves to `true` if the next call to {@link RequestQueue.fetchNextRequest}
      * would return `null`, otherwise it resolves to `false`.
      * Note that even if the queue is empty, there might be some pending requests currently being processed.
-     * If you need to ensure that there is no activity in the queue, use {@apilink RequestQueue.isFinished}.
+     * If you need to ensure that there is no activity in the queue, use {@link RequestQueue.isFinished}.
      */
     isEmpty(): Promise<boolean>;
     /**
@@ -191,14 +191,14 @@ export declare abstract class RequestProvider implements IStorage {
     private _downloadListOfUrls;
     /**
      * Opens a request queue and returns a promise resolving to an instance
-     * of the {@apilink RequestQueue} class.
+     * of the {@link RequestQueue} class.
      *
-     * {@apilink RequestQueue} represents a queue of URLs to crawl, which is stored either on local filesystem or in the cloud.
+     * {@link RequestQueue} represents a queue of URLs to crawl, which is stored either on local filesystem or in the cloud.
      * The queue is used for deep crawling of websites, where you start with several URLs and then
      * recursively follow links to other pages. The data structure supports both breadth-first
      * and depth-first crawling orders.
      *
-     * For more details and code examples, see the {@apilink RequestQueue} class.
+     * For more details and code examples, see the {@link RequestQueue} class.
      *
      * @param [queueIdOrName]
      *   ID or name of the request queue to be opened. If `null` or `undefined`,
@@ -227,7 +227,7 @@ export interface RequestProviderOptions {
     proxyConfiguration?: ProxyConfiguration;
 }
 /**
- * @deprecated Use {@apilink RequestProviderOptions} instead.
+ * @deprecated Use {@link RequestProviderOptions} instead.
  */
 export interface RequestQueueOptions extends RequestProviderOptions {
 }
@@ -244,7 +244,7 @@ export interface RequestQueueOperationOptions {
      * If set to `true`:
      *   - while adding the request to the queue: the request will be added to the foremost position in the queue.
      *   - while reclaiming the request: the request will be placed to the beginning of the queue, so that it's returned
-     *   in the next call to {@apilink RequestQueue.fetchNextRequest}.
+     *   in the next call to {@link RequestQueue.fetchNextRequest}.
      * By default, it's put to the end of the queue.
      *
      * In case the request is already present in the queue, this option has no effect.
@@ -288,8 +288,8 @@ export interface AddRequestsBatchedResult {
     /**
      * A promise which will resolve with the rest of the requests that were added to the queue.
      *
-     * Alternatively, we can set {@apilink AddRequestsBatchedOptions.waitForAllRequestsToBeAdded|`waitForAllRequestsToBeAdded`} to `true`
-     * in the {@apilink BasicCrawler.addRequests|`crawler.addRequests()`} options.
+     * Alternatively, we can set {@link AddRequestsBatchedOptions.waitForAllRequestsToBeAdded|`waitForAllRequestsToBeAdded`} to `true`
+     * in the {@link BasicCrawler.addRequests|`crawler.addRequests()`} options.
      *
      * **Example:**
      *

package/storages/request_provider.js

@@ -165,12 +165,12 @@ class RequestProvider {
      *
      * If a request with the same `uniqueKey` property is already present in the queue,
      * it will not be updated. You can find out whether this happened from the resulting
-     * {@apilink QueueOperationInfo} object.
+     * {@link QueueOperationInfo} object.
      *
      * To add multiple requests to the queue by extracting links from a webpage,
-     * see the {@apilink enqueueLinks} helper function.
+     * see the {@link enqueueLinks} helper function.
      *
-     * @param requestLike {@apilink Request} object or vanilla object with request data.
+     * @param requestLike {@link Request} object or vanilla object with request data.
      * Note that the function sets the `uniqueKey` and `id` fields to the passed Request.
      * @param [options] Request queue operation options.
      */
@@ -228,9 +228,9 @@ class RequestProvider {
      *
      * If a request passed in is already present due to its `uniqueKey` property being the same,
      * it will not be updated. You can find out whether this happened by finding the request in the resulting
-     * {@apilink BatchAddRequestsResult} object.
+     * {@link BatchAddRequestsResult} object.
      *
-     * @param requestsLike {@apilink Request} objects or vanilla objects with request data.
+     * @param requestsLike {@link Request} objects or vanilla objects with request data.
      * Note that the function sets the `uniqueKey` and `id` fields to the passed requests if missing.
      * @param [options] Request queue operation options.
      */
@@ -418,7 +418,7 @@ class RequestProvider {
     }
     /**
      * Marks a request that was previously returned by the
-     * {@apilink RequestQueue.fetchNextRequest}
+     * {@link RequestQueue.fetchNextRequest}
      * function as handled after successful processing.
      * Handled requests will never again be returned by the `fetchNextRequest` function.
      */
@@ -451,7 +451,7 @@ class RequestProvider {
     }
     /**
      * Reclaims a failed request back to the queue, so that it can be returned for processing later again
-     * by another call to {@apilink RequestQueue.fetchNextRequest}.
+     * by another call to {@link RequestQueue.fetchNextRequest}.
      * The request record in the queue is updated using the provided `request` parameter.
      * For example, this lets you store the number of retries or error messages for the request.
      */
@@ -479,10 +479,10 @@ class RequestProvider {
         return queueOperationInfo;
     }
     /**
-     * Resolves to `true` if the next call to {@apilink RequestQueue.fetchNextRequest}
+     * Resolves to `true` if the next call to {@link RequestQueue.fetchNextRequest}
      * would return `null`, otherwise it resolves to `false`.
      * Note that even if the queue is empty, there might be some pending requests currently being processed.
-     * If you need to ensure that there is no activity in the queue, use {@apilink RequestQueue.isFinished}.
+     * If you need to ensure that there is no activity in the queue, use {@link RequestQueue.isFinished}.
      */
     async isEmpty() {
         await this.ensureHeadIsNonEmpty();
@@ -622,14 +622,14 @@ class RequestProvider {
     }
     /**
      * Opens a request queue and returns a promise resolving to an instance
-     * of the {@apilink RequestQueue} class.
+     * of the {@link RequestQueue} class.
      *
-     * {@apilink RequestQueue} represents a queue of URLs to crawl, which is stored either on local filesystem or in the cloud.
+     * {@link RequestQueue} represents a queue of URLs to crawl, which is stored either on local filesystem or in the cloud.
      * The queue is used for deep crawling of websites, where you start with several URLs and then
      * recursively follow links to other pages. The data structure supports both breadth-first
      * and depth-first crawling orders.
      *
-     * For more details and code examples, see the {@apilink RequestQueue} class.
+     * For more details and code examples, see the {@link RequestQueue} class.
      *
      * @param [queueIdOrName]
      *   ID or name of the request queue to be opened. If `null` or `undefined`,

package/storages/request_queue.d.ts

@@ -8,17 +8,17 @@ import { RequestProvider } from './request_provider';
  * where you start with several URLs and then recursively
  * follow links to other pages. The data structure supports both breadth-first and depth-first crawling orders.
  *
- * Each URL is represented using an instance of the {@apilink Request} class.
- * The queue can only contain unique URLs. More precisely, it can only contain {@apilink Request} instances
+ * Each URL is represented using an instance of the {@link Request} class.
+ * The queue can only contain unique URLs. More precisely, it can only contain {@link Request} instances
  * with distinct `uniqueKey` properties. By default, `uniqueKey` is generated from the URL, but it can also be overridden.
  * To add a single URL multiple times to the queue,
- * corresponding {@apilink Request} objects will need to have different `uniqueKey` properties.
+ * corresponding {@link Request} objects will need to have different `uniqueKey` properties.
  *
- * Do not instantiate this class directly, use the {@apilink RequestQueue.open} function instead.
+ * Do not instantiate this class directly, use the {@link RequestQueue.open} function instead.
  *
- * `RequestQueue` is used by {@apilink BasicCrawler}, {@apilink CheerioCrawler}, {@apilink PuppeteerCrawler}
- * and {@apilink PlaywrightCrawler} as a source of URLs to crawl.
- * Unlike {@apilink RequestList}, `RequestQueue` supports dynamic adding and removing of requests.
+ * `RequestQueue` is used by {@link BasicCrawler}, {@link CheerioCrawler}, {@link PuppeteerCrawler}
+ * and {@link PlaywrightCrawler} as a source of URLs to crawl.
+ * Unlike {@link RequestList}, `RequestQueue` supports dynamic adding and removing of requests.
  * On the other hand, the queue is not optimized for operations that add or remove a large number of URLs in a batch.
  *
  * `RequestQueue` stores its data either on local disk or in the Apify Cloud,
@@ -30,7 +30,7 @@ import { RequestProvider } from './request_provider';
  * If the `APIFY_TOKEN` environment variable is set but `APIFY_LOCAL_STORAGE_DIR` is not, the data is stored in the
  * [Apify Request Queue](https://docs.apify.com/storage/request-queue)
  * cloud storage. Note that you can force usage of the cloud storage also by passing the `forceCloud`
- * option to {@apilink RequestQueue.open} function,
+ * option to {@link RequestQueue.open} function,
  * even if the `APIFY_LOCAL_STORAGE_DIR` variable is set.
  *
  * **Example usage:**
@@ -49,7 +49,7 @@ import { RequestProvider } from './request_provider';
  * ```
  * @category Sources
  *
- * @deprecated RequestQueue v1 is deprecated and will be removed in the future. Please use {@apilink RequestQueue} instead.
+ * @deprecated RequestQueue v1 is deprecated and will be removed in the future. Please use {@link RequestQueue} instead.
  */
 declare class RequestQueue extends RequestProvider {
     private queryQueueHeadPromise?;
@@ -66,15 +66,15 @@ declare class RequestQueue extends RequestProvider {
      * Returns a next request in the queue to be processed, or `null` if there are no more pending requests.
      *
      * Once you successfully finish processing of the request, you need to call
-     * {@apilink RequestQueue.markRequestHandled}
+     * {@link RequestQueue.markRequestHandled}
      * to mark the request as handled in the queue. If there was some error in processing the request,
-     * call {@apilink RequestQueue.reclaimRequest} instead,
+     * call {@link RequestQueue.reclaimRequest} instead,
      * so that the queue will give the request to some other consumer in another call to the `fetchNextRequest` function.
      *
      * Note that the `null` return value doesn't mean the queue processing finished,
      * it means there are currently no pending requests.
      * To check whether all requests in queue were finished,
-     * use {@apilink RequestQueue.isFinished} instead.
+     * use {@link RequestQueue.isFinished} instead.
      *
      * @returns
      *   Returns the request object or `null` if there are no more pending requests.
@@ -96,7 +96,7 @@ declare class RequestQueue extends RequestProvider {
     isFinished(): Promise<boolean>;
     /**
      * Reclaims a failed request back to the queue, so that it can be returned for processing later again
-     * by another call to {@apilink RequestQueue.fetchNextRequest}.
+     * by another call to {@link RequestQueue.fetchNextRequest}.
      * The request record in the queue is updated using the provided `request` parameter.
      * For example, this lets you store the number of retries or error messages for the request.
      */
@@ -108,14 +108,14 @@ declare class RequestQueue extends RequestProvider {
     protected _reset(): void;
     /**
      * Opens a request queue and returns a promise resolving to an instance
-     * of the {@apilink RequestQueue} class.
+     * of the {@link RequestQueue} class.
      *
-     * {@apilink RequestQueue} represents a queue of URLs to crawl, which is stored either on local filesystem or in the cloud.
+     * {@link RequestQueue} represents a queue of URLs to crawl, which is stored either on local filesystem or in the cloud.
      * The queue is used for deep crawling of websites, where you start with several URLs and then
      * recursively follow links to other pages. The data structure supports both breadth-first
      * and depth-first crawling orders.
      *
-     * For more details and code examples, see the {@apilink RequestQueue} class.
+     * For more details and code examples, see the {@link RequestQueue} class.
      *
      * @param [queueIdOrName]
      *   ID or name of the request queue to be opened. If `null` or `undefined`,