@mui/internal-code-infra 0.0.3-canary.6 → 0.0.3-canary.61

package/build/markdownlint/index.d.mts

@@ -0,0 +1,56 @@
+/**
+ * Create a base configuration for markdownlint.
+ * @param {Object} options
+ * @param {(typeof straightQuotes)[]} [options.rules] - An array of custom rules to include.
+ * @param {string[]} [options.ignores] - An array of glob patterns to ignore.
+ * @returns
+ */
+export function createBaseConfig(options?: {
+    rules?: {
+        names: string[];
+        description: string;
+        tags: string[];
+        function: (params: import("./duplicate-h1.mjs").MdParams, onError: import("./duplicate-h1.mjs").OnError) => void;
+    }[] | undefined;
+    ignores?: string[] | undefined;
+}): {
+    config: {
+        default: boolean;
+        MD004: boolean;
+        MD009: {
+            br_spaces: number;
+            strict: boolean;
+            list_item_empty_lines: boolean;
+        };
+        MD013: boolean;
+        MD014: boolean;
+        MD024: {
+            siblings_only: boolean;
+        };
+        MD025: {
+            level: number;
+            front_matter_title: string;
+        };
+        MD033: boolean;
+        MD034: boolean;
+        MD028: boolean;
+        MD029: boolean;
+        MD031: boolean;
+        MD036: boolean;
+        MD051: boolean;
+        MD052: boolean;
+        MD059: boolean;
+        straightQuotes: boolean;
+        gitDiff: boolean;
+        tableAlignment: boolean;
+        terminalLanguage: boolean;
+        duplicateH1: boolean;
+    };
+    customRules: {
+        names: string[];
+        description: string;
+        tags: string[];
+        function: (params: import("./duplicate-h1.mjs").MdParams, onError: import("./duplicate-h1.mjs").OnError) => void;
+    }[];
+    ignores: string[];
+};

package/build/markdownlint/straight-quotes.d.mts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    export let names: string[];
+    export let description: string;
+    export let tags: string[];
+    export function _function(params: import("./duplicate-h1.mjs").MdParams, onError: import("./duplicate-h1.mjs").OnError): void;
+    export { _function as function };
+}
+export default _default;

package/build/markdownlint/table-alignment.d.mts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    export let names: string[];
+    export let description: string;
+    export let tags: string[];
+    export function _function(params: import("./duplicate-h1.mjs").MdParams, onError: import("./duplicate-h1.mjs").OnError): void;
+    export { _function as function };
+}
+export default _default;

package/build/markdownlint/terminal-language.d.mts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    export let names: string[];
+    export let description: string;
+    export let tags: string[];
+    export function _function(params: import("./duplicate-h1.mjs").MdParams, onError: import("./duplicate-h1.mjs").OnError): void;
+    export { _function as function };
+}
+export default _default;

package/build/prettier.d.mts

@@ -0,0 +1,20 @@
+/**
+ * @param {Object} [options={}]
+ * @param {Override[]} [options.overrides]
+ * @returns {import('prettier').Config}
+ */
+export function createBaseConfig(options?: {
+    overrides?: {
+        files: string | string[];
+        excludeFiles?: string | string[];
+        options?: import("prettier").Options;
+    }[] | undefined;
+}): import("prettier").Config;
+/**
+ * @typedef {Exclude<import('prettier').Config['overrides'], undefined>[number]} Override
+ */
+/**
+ * @type {Override[]}
+ */
+export const docsOverrides: Override[];
+export type Override = Exclude<import("prettier").Config["overrides"], undefined>[number];

package/build/stylelint/index.d.mts

@@ -0,0 +1,32 @@
+declare const _default: {
+    extends: (string | string[]) | undefined;
+    rules: {
+        'no-descending-specificity': null;
+        'alpha-value-notation': null;
+        'custom-property-pattern': null;
+        'media-feature-range-notation': null;
+        'no-empty-source': null;
+        'selector-class-pattern': null;
+        'string-no-newline': null;
+        'value-keyword-case': null;
+        'import-notation': null;
+        'at-rule-empty-line-before': null;
+        'comment-empty-line-before': null;
+        'custom-property-empty-line-before': null;
+        'declaration-empty-line-before': null;
+        'rule-empty-line-before': null;
+        'at-rule-no-unknown': (boolean | {
+            ignoreAtRules: string[];
+        })[];
+        'property-no-vendor-prefix': null;
+        'property-no-deprecated': null;
+        'declaration-property-value-keyword-no-deprecated': null;
+        'color-hex-length': null;
+        'declaration-block-no-redundant-longhand-properties': null;
+    };
+    overrides: {
+        files: string[];
+        customSyntax: any;
+    }[];
+};
+export default _default;

package/build/utils/babel.d.mts

@@ -0,0 +1,71 @@
+/**
+ * @param {string} pkgVersion
+ * @returns {Record<string, string>} An object containing version-related environment variables.
+ */
+export function getVersionEnvVariables(pkgVersion: string): Record<string, string>;
+/**
+ * Copies CommonJS files from one directory to another.
+ * @param {Object} param0
+ * @param {string} param0.from - The source directory.
+ * @param {string} param0.to - The destination directory.
+ * @returns {Promise<void>}
+ */
+export function cjsCopy({ from, to }: {
+    from: string;
+    to: string;
+}): Promise<void>;
+/**
+ * @typedef {Object} ErrorCodeMetadata
+ * @property {string} outputPath - The path where the error code file should be written.
+ * @property {'annotate' | 'throw' | 'write'} [missingError] - How to handle missing error codes.
+ * @property {string} [runtimeModule] - The runtime module to replace the errors with.
+ */
+/**
+ * @param {Object} options
+ * @param {boolean} [options.verbose=false] - Whether to enable verbose logging.
+ * @param {boolean} [options.optimizeClsx=false] - Whether to enable clsx call optimization transform.
+ * @param {boolean} [options.removePropTypes=true] - Whether to enable removal of React prop types.
+ * @param {Object} [options.reactCompiler] - Whether to use the React compiler.
+ * @param {string} [options.reactCompiler.reactVersion] - The React version to use with the React compiler.
+ * @param {string[]} [options.ignores] - The globs to be ignored by Babel.
+ * @param {string} options.cwd - The package root directory.
+ * @param {string} options.pkgVersion - The package version.
+ * @param {string} options.sourceDir - The source directory to build from.
+ * @param {string} options.outDir - The output directory for the build.
+ * @param {string} options.outExtension - The output file extension for the build.
+ * @param {boolean} options.hasLargeFiles - Whether the build includes large files.
+ * @param {import('./build.mjs').BundleType} options.bundle - The bundles to build.
+ * @param {string} options.babelRuntimeVersion - The version of @babel/runtime to use.
+ * @returns {Promise<void>}
+ */
+export function babelBuild({ cwd, sourceDir, outDir, babelRuntimeVersion, hasLargeFiles, bundle, pkgVersion, outExtension, optimizeClsx, removePropTypes, verbose, ignores, reactCompiler, }: {
+    verbose?: boolean | undefined;
+    optimizeClsx?: boolean | undefined;
+    removePropTypes?: boolean | undefined;
+    reactCompiler?: {
+        reactVersion?: string | undefined;
+    } | undefined;
+    ignores?: string[] | undefined;
+    cwd: string;
+    pkgVersion: string;
+    sourceDir: string;
+    outDir: string;
+    outExtension: string;
+    hasLargeFiles: boolean;
+    bundle: import("./build.mjs").BundleType;
+    babelRuntimeVersion: string;
+}): Promise<void>;
+export type ErrorCodeMetadata = {
+    /**
+     * - The path where the error code file should be written.
+     */
+    outputPath: string;
+    /**
+     * - How to handle missing error codes.
+     */
+    missingError?: "throw" | "annotate" | "write" | undefined;
+    /**
+     * - The runtime module to replace the errors with.
+     */
+    runtimeModule?: string | undefined;
+};

package/build/utils/build.d.mts

@@ -0,0 +1,50 @@
+/**
+ * @param {BundleType} bundle
+ */
+export function getOutExtension(bundle: BundleType, isType?: boolean): ".mjs" | ".js" | ".d.ts" | ".d.mts";
+/**
+ * Validates the package.json before building.
+ * @param {Record<string, any>} packageJson
+ * @param {Object} [options]
+ * @param {boolean} [options.skipMainCheck=false] - Whether to skip checking for main field in package.json.
+ * @param {boolean} [options.enableReactCompiler=false] - Whether to enable React compiler checks.
+ */
+export function validatePkgJson(packageJson: Record<string, any>, options?: {
+    skipMainCheck?: boolean | undefined;
+    enableReactCompiler?: boolean | undefined;
+}): void;
+/**
+ * Marks the start and end of a function execution for performance measurement.
+ * Uses the Performance API to create marks and measure the duration.
+ * @function
+ * @template {() => Promise<any>} F
+ * @param {string} label
+ * @param {() => ReturnType<F>} fn
+ * @returns {Promise<ReturnType<F>>}
+ */
+export function markFn<F extends () => Promise<any>>(label: string, fn: () => ReturnType<F>): Promise<ReturnType<F>>;
+/**
+ * @param {string} label
+ */
+export function measureFn(label: string): PerformanceMeasure;
+/**
+ * A utility to map a function over an array of items in a worker pool.
+ *
+ * This function will create a pool of workers and distribute the items to be processed among them.
+ * Each worker will process items sequentially, but multiple workers will run in parallel.
+ *
+ * @function
+ * @template T
+ * @template R
+ * @param {T[]} items
+ * @param {(item: T) => Promise<R>} mapper
+ * @param {number} concurrency
+ * @returns {Promise<(R|Error)[]>}
+ */
+export function mapConcurrently<T, R>(items: T[], mapper: (item: T) => Promise<R>, concurrency: number): Promise<(R | Error)[]>;
+/**
+ * @typedef {'esm' | 'cjs'} BundleType
+ */
+export const isMjsBuild: boolean;
+export const BASE_IGNORES: string[];
+export type BundleType = "esm" | "cjs";

package/build/utils/changelog.d.mts

@@ -0,0 +1,64 @@
+/**
+ * @typedef {import('@octokit/rest').Octokit} OctokitType
+ */
+/**
+ * @typedef {'team' | 'first_timer' | 'contributor'} AuthorAssociation
+ */
+/**
+ * @typedef {Object} FetchedCommitDetails
+ * @property {string} sha
+ * @property {string} message
+ * @property {string[]} labels
+ * @property {number} prNumber
+ * @property {string} html_url
+ * @property {{login: string; association: AuthorAssociation} | null} author
+ */
+/**
+ * @typedef {Object} FetchCommitsOptions
+ * @property {string} repo
+ * @property {string} lastRelease
+ * @property {string} release
+ * @property {string} [org='mui'] - GitHub organization name, defaults to 'mui'
+ */
+/**
+ * @param {Object} opts
+ * @param {string} opts.cwd
+ * @param {boolean} [opts.fetchAll=true] Whether to fetch all tags from all remotes before finding the latest tag.
+ * @returns {Promise<string>}
+ */
+export function findLatestTaggedVersion(opts: {
+    cwd: string;
+    fetchAll?: boolean | undefined;
+}): Promise<string>;
+/**
+ * Fetches commits between two refs (lastRelease..release) including PR details.
+ * Automatically handles GitHub OAuth authentication if none provided.
+ *
+ * @param {FetchCommitsOptions & {octokit?: OctokitType}} opts
+ * @returns {Promise<FetchedCommitDetails[]>}
+ */
+export function fetchCommitsBetweenRefs(opts: FetchCommitsOptions & {
+    octokit?: OctokitType;
+}): Promise<FetchedCommitDetails[]>;
+export type OctokitType = import("@octokit/rest").Octokit;
+export type AuthorAssociation = "team" | "first_timer" | "contributor";
+export type FetchedCommitDetails = {
+    sha: string;
+    message: string;
+    labels: string[];
+    prNumber: number;
+    html_url: string;
+    author: {
+        login: string;
+        association: AuthorAssociation;
+    } | null;
+};
+export type FetchCommitsOptions = {
+    repo: string;
+    lastRelease: string;
+    release: string;
+    /**
+     * - GitHub organization name, defaults to 'mui'
+     */
+    org?: string | undefined;
+};

package/build/utils/credentials.d.mts

@@ -0,0 +1,17 @@
+/**
+ * @param {string} key
+ * @returns {Promise<string | undefined>}
+ */
+export function getPassword(key: string): Promise<string | undefined>;
+/**
+ * @param {string} key
+ * @param {string} password
+ * @returns {Promise<void>}
+ */
+export function setPassword(key: string, password: string): Promise<void>;
+/**
+ * @param {string} key
+ * @returns {Promise<void>}
+ */
+export function deleteKey(key: string): Promise<void>;
+export const KEYRING_SERVICE: "mui-code-infra";

package/build/utils/extractErrorCodes.d.mts

@@ -0,0 +1,19 @@
+/**
+ * Extracts error codes from all workspace packages.
+ * @param {Args} args
+ */
+export default function extractErrorCodes(args: Args): Promise<void>;
+export type Args = {
+    /**
+     * - The output path to write the extracted error codes.
+     */
+    errorCodesPath: string;
+    /**
+     * - List of package names to skip. By default, all workspace packages are considered.
+     */
+    skip?: string[] | undefined;
+    /**
+     * - The detection strategy to use when extracting error codes.
+     */
+    detection?: import("@mui/internal-babel-plugin-minify-errors").Options["detection"];
+};

package/build/utils/git.d.mts

@@ -0,0 +1,26 @@
+/**
+ * @typedef {Object} RepoInfo
+ * @property {string} owner - Repository owner
+ * @property {string} repo - Repository name
+ */
+/**
+ * Get current repository info from git remote
+ * @param {string[]} [remotes=['upstream', 'origin']] - Remote name(s) to check (default: ['upstream', 'origin'])
+ * @returns {Promise<RepoInfo>} Repository owner and name
+ */
+export function getRepositoryInfo(remotes?: string[]): Promise<RepoInfo>;
+/**
+ * Get current git SHA
+ * @returns {Promise<string>} Current git commit SHA
+ */
+export function getCurrentGitSha(): Promise<string>;
+export type RepoInfo = {
+    /**
+     * - Repository owner
+     */
+    owner: string;
+    /**
+     * - Repository name
+     */
+    repo: string;
+};

package/build/utils/github.d.mts

@@ -0,0 +1,41 @@
+/**
+ * @typedef {Object} GitHubAppAuthenticationWithRefreshToken
+ * @property {string} token - The access token
+ * @property {string} [expiresAt] - ISO string when the access token expires
+ * @property {string} [refreshToken] - The refresh token
+ * @property {string} [refreshTokenExpiresAt] - ISO string when the refresh token expires
+ */
+export function persistentAuthStrategy(): {
+    hook: (request: import("@octokit/types").RequestInterface, route: import("@octokit/types").Route, parameters: import("@octokit/types").RequestParameters) => Promise<import("@octokit/types").OctokitResponse<any, number>>;
+};
+/**
+ * @param {Object} [options]
+ * @param {boolean} [options.log=false] - Whether to log progress to console
+ * @returns {Promise<string>} Valid GitHub access token
+ */
+export function endToEndGhAuthGetToken({ log }?: {
+    log?: boolean | undefined;
+}): Promise<string>;
+/**
+ * Clears stored GitHub authentication tokens
+ * @returns {Promise<void>}
+ */
+export function clearGitHubAuth(): Promise<void>;
+export type GitHubAppAuthenticationWithRefreshToken = {
+    /**
+     * - The access token
+     */
+    token: string;
+    /**
+     * - ISO string when the access token expires
+     */
+    expiresAt?: string | undefined;
+    /**
+     * - The refresh token
+     */
+    refreshToken?: string | undefined;
+    /**
+     * - ISO string when the refresh token expires
+     */
+    refreshTokenExpiresAt?: string | undefined;
+};

package/build/utils/pnpm.d.mts

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+/**
+ * Get workspace packages with optional filtering
+ *
+ * @overload
+ * @param {{ publicOnly: true } & GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<PublicPackage[]>} Array of packages
+ *
+ * @overload
+ * @param {{ nonPublishedOnly: true } & GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<PublicPackage[]>} Array of packages
+ *
+ * @overload
+ * @param {{ publicOnly?: false | undefined } & GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<PrivatePackage[]>} Array of packages
+ *
+ * @overload
+ * @param {GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<(PrivatePackage | PublicPackage)[]>} Array of packages
+ *
+ * @param {GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<(PrivatePackage | PublicPackage)[]>} Array of packages
+ */
+export function getWorkspacePackages(options?: ({
+    publicOnly: true;
+} & GetWorkspacePackagesOptions) | undefined): Promise<PublicPackage[]>;
+/**
+ * Get workspace packages with optional filtering
+ *
+ * @overload
+ * @param {{ publicOnly: true } & GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<PublicPackage[]>} Array of packages
+ *
+ * @overload
+ * @param {{ nonPublishedOnly: true } & GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<PublicPackage[]>} Array of packages
+ *
+ * @overload
+ * @param {{ publicOnly?: false | undefined } & GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<PrivatePackage[]>} Array of packages
+ *
+ * @overload
+ * @param {GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<(PrivatePackage | PublicPackage)[]>} Array of packages
+ *
+ * @param {GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<(PrivatePackage | PublicPackage)[]>} Array of packages
+ */
+export function getWorkspacePackages(options?: ({
+    nonPublishedOnly: true;
+} & GetWorkspacePackagesOptions) | undefined): Promise<PublicPackage[]>;
+/**
+ * Get workspace packages with optional filtering
+ *
+ * @overload
+ * @param {{ publicOnly: true } & GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<PublicPackage[]>} Array of packages
+ *
+ * @overload
+ * @param {{ nonPublishedOnly: true } & GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<PublicPackage[]>} Array of packages
+ *
+ * @overload
+ * @param {{ publicOnly?: false | undefined } & GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<PrivatePackage[]>} Array of packages
+ *
+ * @overload
+ * @param {GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<(PrivatePackage | PublicPackage)[]>} Array of packages
+ *
+ * @param {GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<(PrivatePackage | PublicPackage)[]>} Array of packages
+ */
+export function getWorkspacePackages(options?: ({
+    publicOnly?: false | undefined;
+} & GetWorkspacePackagesOptions) | undefined): Promise<PrivatePackage[]>;
+/**
+ * Get workspace packages with optional filtering
+ *
+ * @overload
+ * @param {{ publicOnly: true } & GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<PublicPackage[]>} Array of packages
+ *
+ * @overload
+ * @param {{ nonPublishedOnly: true } & GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<PublicPackage[]>} Array of packages
+ *
+ * @overload
+ * @param {{ publicOnly?: false | undefined } & GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<PrivatePackage[]>} Array of packages
+ *
+ * @overload
+ * @param {GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<(PrivatePackage | PublicPackage)[]>} Array of packages
+ *
+ * @param {GetWorkspacePackagesOptions} [options={}] - Options for filtering packages
+ * @returns {Promise<(PrivatePackage | PublicPackage)[]>} Array of packages
+ */
+export function getWorkspacePackages(options?: GetWorkspacePackagesOptions | undefined): Promise<(PrivatePackage | PublicPackage)[]>;
+/**
+ * Get package version info from registry
+ * @param {string} packageName - Name of the package
+ * @param {string} baseVersion - Base version to check
+ * @returns {Promise<VersionInfo>} Version information
+ */
+export function getPackageVersionInfo(packageName: string, baseVersion: string): Promise<VersionInfo>;
+/**
+ * Publish packages with the given options
+ * @param {PublicPackage[]} packages - Packages to publish
+ * @param {PublishOptions} [options={}] - Publishing options
+ * @returns {Promise<void>}
+ */
+export function publishPackages(packages: PublicPackage[], options?: PublishOptions): Promise<void>;
+/**
+ * Read package.json from a directory
+ * @param {string} packagePath - Path to package directory
+ * @returns {Promise<import('../cli/packageJson').PackageJson>} Parsed package.json content
+ */
+export function readPackageJson(packagePath: string): Promise<import("../cli/packageJson").PackageJson>;
+/**
+ * Write package.json to a directory
+ * @param {string} packagePath - Path to package directory
+ * @param {Object} packageJson - Package.json object to write
+ * @returns {Promise<void>}
+ */
+export function writePackageJson(packagePath: string, packageJson: Object): Promise<void>;
+/**
+ * Resolve a package@version specifier to an exact version
+ * @param {string} packageSpec - Package specifier in format "package@version"
+ * @returns {Promise<string>} Exact version string
+ */
+export function resolveVersion(packageSpec: string): Promise<string>;
+/**
+ * Find the version of a dependency for a specific package@version
+ * @param {string} packageSpec - Package specifier in format "package@version"
+ * @param {string} dependency - Dependency name to look up
+ * @returns {Promise<string>} Exact version string of the dependency
+ */
+export function findDependencyVersionFromSpec(packageSpec: string, dependency: string): Promise<string>;
+/**
+ * Get the maximum semver version between two versions
+ * @param {string} a
+ * @param {string} b
+ * @returns {string} The maximum semver version
+ */
+export function semverMax(a: string, b: string): string;
+export type PrivatePackage = {
+    /**
+     * - Package name
+     */
+    name?: string | undefined;
+    /**
+     * - Package version
+     */
+    version?: string | undefined;
+    /**
+     * - Package directory path
+     */
+    path: string;
+    /**
+     * - Whether the package is private
+     */
+    isPrivate: true;
+};
+export type PublicPackage = {
+    /**
+     * - Package name
+     */
+    name: string;
+    /**
+     * - Package version
+     */
+    version: string;
+    /**
+     * - Package directory path
+     */
+    path: string;
+    /**
+     * - Whether the package is private
+     */
+    isPrivate: false;
+};
+export type VersionInfo = {
+    /**
+     * - Whether current version exists on npm
+     */
+    currentVersionExists: boolean;
+    /**
+     * - Latest canary version if available
+     */
+    latestCanaryVersion: string | null;
+};
+export type PublishOptions = {
+    /**
+     * - Whether to run in dry-run mode
+     */
+    dryRun?: boolean | undefined;
+    /**
+     * - Whether to skip git checks
+     */
+    noGitChecks?: boolean | undefined;
+    /**
+     * - NPM dist tag to publish to
+     */
+    tag?: string | undefined;
+};
+export type PnpmListResultItem = {
+    /**
+     * - Package name
+     */
+    name?: string | undefined;
+    /**
+     * - Package version
+     */
+    version?: string | undefined;
+    /**
+     * - Package directory path
+     */
+    path: string;
+    /**
+     * - Whether the package is private
+     */
+    private: boolean;
+};
+export type GetWorkspacePackagesOptions = {
+    /**
+     * - Git reference to filter changes since
+     */
+    sinceRef?: string | null | undefined;
+    /**
+     * - Whether to filter to only public packages
+     */
+    publicOnly?: boolean | undefined;
+    /**
+     * - Whether to filter to only non-published packages. It by default means public packages yet to be published.
+     */
+    nonPublishedOnly?: boolean | undefined;
+};