projen 0.98.4__py3-none-any.whl → 0.98.5__py3-none-any.whl

projen/__init__.py

@@ -607,6 +607,158 @@ from ._jsii import *
 import constructs as _constructs_77d1e7e8
 
 
+@jsii.enum(jsii_type="projen.AiAgent")
+class AiAgent(enum.Enum):
+    '''(experimental) Supported AI coding assistants and their instruction file locations.
+
+    :stability: experimental
+    '''
+
+    GITHUB_COPILOT = "GITHUB_COPILOT"
+    '''(experimental) GitHub Copilot - .github/copilot-instructions.md.
+
+    :stability: experimental
+    '''
+    CURSOR = "CURSOR"
+    '''(experimental) Cursor IDE - .cursor/rules/project.md.
+
+    :stability: experimental
+    '''
+    CLAUDE = "CLAUDE"
+    '''(experimental) Claude Code - CLAUDE.md.
+
+    :stability: experimental
+    '''
+    AMAZON_Q = "AMAZON_Q"
+    '''(experimental) Amazon Q - .amazonq/rules/project.md.
+
+    :stability: experimental
+    '''
+    KIRO = "KIRO"
+    '''(experimental) Kiro - .kiro/steering/project.md.
+
+    :stability: experimental
+    '''
+
+
+@jsii.data_type(
+    jsii_type="projen.AiInstructionsOptions",
+    jsii_struct_bases=[],
+    name_mapping={
+        "agents": "agents",
+        "agent_specific_instructions": "agentSpecificInstructions",
+        "include_default_instructions": "includeDefaultInstructions",
+        "instructions": "instructions",
+    },
+)
+class AiInstructionsOptions:
+    def __init__(
+        self,
+        *,
+        agents: typing.Optional[typing.Sequence[AiAgent]] = None,
+        agent_specific_instructions: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[builtins.str]]] = None,
+        include_default_instructions: typing.Optional[builtins.bool] = None,
+        instructions: typing.Optional[typing.Sequence[builtins.str]] = None,
+    ) -> None:
+        '''(experimental) Options for configuring AI tool instruction files.
+
+        :param agents: (experimental) Which AI agents to generate instruction files for. Default: - All agents: [AiAgent.GITHUB_COPILOT, AiAgent.CURSOR, AiAgent.CLAUDE, AiAgent.AMAZON_Q]
+        :param agent_specific_instructions: (experimental) Per-agent custom instructions. Allows different instructions for different AI tools. Default: - no agent specific instructions
+        :param include_default_instructions: (experimental) Include default instructions for projen and general best practices. Default instructions will only be included for agents provided in the ``agents`` option. If ``agents`` is not provided, default instructions will be included for all agents. Default: true
+        :param instructions: (experimental) General instructions applicable to all agents. Default: - no agent specific instructions
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__5bf7714efdf83cf2031e4ef3aa1d0cb9511cb921777751c76a0f501c0c56e247)
+            check_type(argname="argument agents", value=agents, expected_type=type_hints["agents"])
+            check_type(argname="argument agent_specific_instructions", value=agent_specific_instructions, expected_type=type_hints["agent_specific_instructions"])
+            check_type(argname="argument include_default_instructions", value=include_default_instructions, expected_type=type_hints["include_default_instructions"])
+            check_type(argname="argument instructions", value=instructions, expected_type=type_hints["instructions"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if agents is not None:
+            self._values["agents"] = agents
+        if agent_specific_instructions is not None:
+            self._values["agent_specific_instructions"] = agent_specific_instructions
+        if include_default_instructions is not None:
+            self._values["include_default_instructions"] = include_default_instructions
+        if instructions is not None:
+            self._values["instructions"] = instructions
+
+    @builtins.property
+    def agents(self) -> typing.Optional[typing.List[AiAgent]]:
+        '''(experimental) Which AI agents to generate instruction files for.
+
+        :default: - All agents: [AiAgent.GITHUB_COPILOT, AiAgent.CURSOR, AiAgent.CLAUDE, AiAgent.AMAZON_Q]
+
+        :stability: experimental
+        '''
+        result = self._values.get("agents")
+        return typing.cast(typing.Optional[typing.List[AiAgent]], result)
+
+    @builtins.property
+    def agent_specific_instructions(
+        self,
+    ) -> typing.Optional[typing.Mapping[builtins.str, typing.List[builtins.str]]]:
+        '''(experimental) Per-agent custom instructions.
+
+        Allows different instructions for different AI tools.
+
+        :default: - no agent specific instructions
+
+        :stability: experimental
+
+        Example::
+
+            {
+              [AiAgent.GITHUB_COPILOT]: {
+                instructions: ["Use descriptive commit messages."]
+              },
+              [AiAgent.CURSOR]: {
+                instructions: ["Prefer functional patterns.", "Always add tests."]
+              }
+            }
+        '''
+        result = self._values.get("agent_specific_instructions")
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.List[builtins.str]]], result)
+
+    @builtins.property
+    def include_default_instructions(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Include default instructions for projen and general best practices.
+
+        Default instructions will only be included for agents provided in the ``agents`` option.
+        If ``agents`` is not provided, default instructions will be included for all agents.
+
+        :default: true
+
+        :stability: experimental
+        '''
+        result = self._values.get("include_default_instructions")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def instructions(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) General instructions applicable to all agents.
+
+        :default: - no agent specific instructions
+
+        :stability: experimental
+        '''
+        result = self._values.get("instructions")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "AiInstructionsOptions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 class Component(
     _constructs_77d1e7e8.Construct,
     metaclass=jsii.JSIIMeta,
@@ -11236,6 +11388,217 @@ class YamlFileOptions(ObjectFileOptions):
         )
 
 
+class AiInstructions(
+    Component,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="projen.AiInstructions",
+):
+    '''(experimental) Generates instruction files for AI coding assistants with projen-specific guidance.
+
+    This component creates configuration files that help AI tools like GitHub Copilot,
+    Cursor IDE, Claude Code, and Amazon Q understand that the project is managed by projen
+    and should follow projen conventions.
+
+    :stability: experimental
+
+    Example::
+
+        const project = new TypeScriptProject({
+          name: "my-project",
+          defaultReleaseBranch: "main",
+        });
+        
+        // Basic usage - generates files for all supported AI agents
+        new AiInstructions(project);
+        
+        // Custom usage - specify which agents and add custom instructions
+        new AiInstructions(project, {
+          agents: [AiAgent.GITHUB_COPILOT, AiAgent.CURSOR],
+          agentSpecificInstructions: {
+            [AiAgent.GITHUB_COPILOT]: ["Always use descriptive commit messages."],
+          },
+        });
+        
+        // Add more instructions after instantiation
+        const ai = new AiInstructions(project);
+        ai.addInstructions("Use functional programming patterns.");
+        ai.addInstructions("Always write comprehensive tests.");
+    '''
+
+    def __init__(
+        self,
+        project: Project,
+        *,
+        agents: typing.Optional[typing.Sequence[AiAgent]] = None,
+        agent_specific_instructions: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[builtins.str]]] = None,
+        include_default_instructions: typing.Optional[builtins.bool] = None,
+        instructions: typing.Optional[typing.Sequence[builtins.str]] = None,
+    ) -> None:
+        '''
+        :param project: -
+        :param agents: (experimental) Which AI agents to generate instruction files for. Default: - All agents: [AiAgent.GITHUB_COPILOT, AiAgent.CURSOR, AiAgent.CLAUDE, AiAgent.AMAZON_Q]
+        :param agent_specific_instructions: (experimental) Per-agent custom instructions. Allows different instructions for different AI tools. Default: - no agent specific instructions
+        :param include_default_instructions: (experimental) Include default instructions for projen and general best practices. Default instructions will only be included for agents provided in the ``agents`` option. If ``agents`` is not provided, default instructions will be included for all agents. Default: true
+        :param instructions: (experimental) General instructions applicable to all agents. Default: - no agent specific instructions
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__6ade3e0209730c28511c6c65af7db0ef1d8f6d736618b1a95064af6bf4e829b8)
+            check_type(argname="argument project", value=project, expected_type=type_hints["project"])
+        options = AiInstructionsOptions(
+            agents=agents,
+            agent_specific_instructions=agent_specific_instructions,
+            include_default_instructions=include_default_instructions,
+            instructions=instructions,
+        )
+
+        jsii.create(self.__class__, self, [project, options])
+
+    @jsii.member(jsii_name="bestPractices")
+    @builtins.classmethod
+    def best_practices(cls, project: Project) -> builtins.str:
+        '''(experimental) Returns development best practices instructions for AI agents.
+
+        :param project: -
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__9b3a19a4e1f7d40bf00205a6394247af85d2428c672a0ecb7904470daaabda2f)
+            check_type(argname="argument project", value=project, expected_type=type_hints["project"])
+        return typing.cast(builtins.str, jsii.sinvoke(cls, "bestPractices", [project]))
+
+    @jsii.member(jsii_name="projen")
+    @builtins.classmethod
+    def projen(cls, project: Project) -> builtins.str:
+        '''(experimental) Returns projen-specific instructions for AI agents.
+
+        :param project: -
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__065453e2727d00b362bd1cf1f58d194d6c355b2a9c2f575e92c43eb627f6eb89)
+            check_type(argname="argument project", value=project, expected_type=type_hints["project"])
+        return typing.cast(builtins.str, jsii.sinvoke(cls, "projen", [project]))
+
+    @jsii.member(jsii_name="addAgentSpecificInstructions")
+    def add_agent_specific_instructions(
+        self,
+        agent: AiAgent,
+        *instructions: builtins.str,
+    ) -> None:
+        '''(experimental) Add instructions for a specific AI agent.
+
+        This can also be used to add instructions for an AI agent that was previously not enabled.
+
+        :param agent: The AI agent to add instructions for.
+        :param instructions: The instruction(s) to add.
+
+        :stability: experimental
+
+        Example::
+
+            aiInstructions.addAgentSpecificInstructions(AiAgent.GITHUB_COPILOT, "Use descriptive commit messages.");
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__9ff14bf0a463b0f887b122f5949af2eedda259c6426a05e006686653e81b8fc8)
+            check_type(argname="argument agent", value=agent, expected_type=type_hints["agent"])
+            check_type(argname="argument instructions", value=instructions, expected_type=typing.Tuple[type_hints["instructions"], ...]) # pyright: ignore [reportGeneralTypeIssues]
+        return typing.cast(None, jsii.invoke(self, "addAgentSpecificInstructions", [agent, *instructions]))
+
+    @jsii.member(jsii_name="addInstructions")
+    def add_instructions(self, *instructions: builtins.str) -> None:
+        '''(experimental) Adds instructions that will be included for all selected AI agents.
+
+        :param instructions: The instructions to add.
+
+        :stability: experimental
+
+        Example::
+
+            aiInstructions.addInstructions("Always use TypeScript strict mode.");
+            aiInstructions.addInstructions("Prefer functional programming.", "Avoid mutations.");
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__da44882109eef43fd7d698b3f301b9241d695eb97a717ffa73265862f39698ba)
+            check_type(argname="argument instructions", value=instructions, expected_type=typing.Tuple[type_hints["instructions"], ...]) # pyright: ignore [reportGeneralTypeIssues]
+        return typing.cast(None, jsii.invoke(self, "addInstructions", [*instructions]))
+
+
+class AiInstructionsFile(
+    FileBase,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="projen.AiInstructionsFile",
+):
+    '''
+    :stability: experimental
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.IConstruct,
+        file_path: builtins.str,
+        *,
+        committed: typing.Optional[builtins.bool] = None,
+        edit_gitignore: typing.Optional[builtins.bool] = None,
+        executable: typing.Optional[builtins.bool] = None,
+        marker: typing.Optional[builtins.bool] = None,
+        readonly: typing.Optional[builtins.bool] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param file_path: -
+        :param committed: (experimental) Indicates whether this file should be committed to git or ignored. By default, all generated files are committed and anti-tamper is used to protect against manual modifications. Default: true
+        :param edit_gitignore: (experimental) Update the project's .gitignore file. Default: true
+        :param executable: (experimental) Whether the generated file should be marked as executable. Default: false
+        :param marker: (experimental) Adds the projen marker to the file. Default: - marker will be included as long as the project is not ejected
+        :param readonly: (experimental) Whether the generated file should be readonly. Default: true
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__4b11da88a3895fa642ead3d82823bc49f77ad84be5d7816af5a52334434c5c79)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument file_path", value=file_path, expected_type=type_hints["file_path"])
+        options = FileBaseOptions(
+            committed=committed,
+            edit_gitignore=edit_gitignore,
+            executable=executable,
+            marker=marker,
+            readonly=readonly,
+        )
+
+        jsii.create(self.__class__, self, [scope, file_path, options])
+
+    @jsii.member(jsii_name="addInstructions")
+    def add_instructions(self, *instructions: builtins.str) -> None:
+        '''(experimental) Adds instructions to the instruction file.
+
+        :param instructions: -
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__da3f715a19bd0c18e2cc2d3bda06afae637174acbe15ef75ef39bb7c26f0ff90)
+            check_type(argname="argument instructions", value=instructions, expected_type=typing.Tuple[type_hints["instructions"], ...]) # pyright: ignore [reportGeneralTypeIssues]
+        return typing.cast(None, jsii.invoke(self, "addInstructions", [*instructions]))
+
+    @jsii.member(jsii_name="synthesizeContent")
+    def _synthesize_content(self, resolver: IResolver) -> typing.Optional[builtins.str]:
+        '''(experimental) Implemented by derived classes and returns the contents of the file to emit.
+
+        :param resolver: -
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__af1c3edb2730dd42712c19d9f2ebd48921303c4efd980f8910326afc111d82cc)
+            check_type(argname="argument resolver", value=resolver, expected_type=type_hints["resolver"])
+        return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "synthesizeContent", [resolver]))
+
+
 @jsii.data_type(
     jsii_type="projen.Dependency",
     jsii_struct_bases=[DependencyCoordinates],
@@ -12575,6 +12938,10 @@ class TaskStep(TaskStepOptions):
 
 
 __all__ = [
+    "AiAgent",
+    "AiInstructions",
+    "AiInstructionsFile",
+    "AiInstructionsOptions",
     "Component",
     "CreateProjectOptions",
     "Dependencies",
@@ -12725,6 +13092,16 @@ from . import typescript
 from . import vscode
 from . import web
 
+def _typecheckingstub__5bf7714efdf83cf2031e4ef3aa1d0cb9511cb921777751c76a0f501c0c56e247(
+    *,
+    agents: typing.Optional[typing.Sequence[AiAgent]] = None,
+    agent_specific_instructions: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[builtins.str]]] = None,
+    include_default_instructions: typing.Optional[builtins.bool] = None,
+    instructions: typing.Optional[typing.Sequence[builtins.str]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__e4ee40327ed6d04e3e377e300d915d402c50029248a86452fd19fd6372386d4b(
     scope: _constructs_77d1e7e8.IConstruct,
     id: typing.Optional[builtins.str] = None,
@@ -14406,6 +14783,67 @@ def _typecheckingstub__ca9e5a70f67f8e3db454227249c58dd5464be1446a55fcf3be780621f
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__6ade3e0209730c28511c6c65af7db0ef1d8f6d736618b1a95064af6bf4e829b8(
+    project: Project,
+    *,
+    agents: typing.Optional[typing.Sequence[AiAgent]] = None,
+    agent_specific_instructions: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[builtins.str]]] = None,
+    include_default_instructions: typing.Optional[builtins.bool] = None,
+    instructions: typing.Optional[typing.Sequence[builtins.str]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__9b3a19a4e1f7d40bf00205a6394247af85d2428c672a0ecb7904470daaabda2f(
+    project: Project,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__065453e2727d00b362bd1cf1f58d194d6c355b2a9c2f575e92c43eb627f6eb89(
+    project: Project,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__9ff14bf0a463b0f887b122f5949af2eedda259c6426a05e006686653e81b8fc8(
+    agent: AiAgent,
+    *instructions: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__da44882109eef43fd7d698b3f301b9241d695eb97a717ffa73265862f39698ba(
+    *instructions: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__4b11da88a3895fa642ead3d82823bc49f77ad84be5d7816af5a52334434c5c79(
+    scope: _constructs_77d1e7e8.IConstruct,
+    file_path: builtins.str,
+    *,
+    committed: typing.Optional[builtins.bool] = None,
+    edit_gitignore: typing.Optional[builtins.bool] = None,
+    executable: typing.Optional[builtins.bool] = None,
+    marker: typing.Optional[builtins.bool] = None,
+    readonly: typing.Optional[builtins.bool] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__da3f715a19bd0c18e2cc2d3bda06afae637174acbe15ef75ef39bb7c26f0ff90(
+    *instructions: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__af1c3edb2730dd42712c19d9f2ebd48921303c4efd980f8910326afc111d82cc(
+    resolver: IResolver,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__d3a39137d5e4f9c51c84e6a659a0e0d16c23ba1927ed8fe7f3f96ecd5d0110dc(
     *,
     name: builtins.str,

projen/_jsii/__init__.py

@@ -31,7 +31,7 @@ def check_type(argname: str, value: object, expected_type: typing.Any) -> typing
 import constructs._jsii
 
 __jsii_assembly__ = jsii.JSIIAssembly.load(
-    "projen", "0.98.4", __name__[0:-6], "projen@0.98.4.jsii.tgz"
+    "projen", "0.98.5", __name__[0:-6], "projen@0.98.5.jsii.tgz"
 )
 
 __all__ = [

projen/javascript/biome_config/__init__.py

@@ -718,7 +718,7 @@ class CssFormatterConfiguration:
         :param enabled: (experimental) Control the formatter for CSS (and its super languages) files.
         :param indent_style: (experimental) The indent style applied to CSS (and its super languages) files.
         :param indent_width: (experimental) The size of the indentation applied to CSS (and its super languages) files. Default to 2. Default: 2.
-        :param line_ending: (experimental) The type of line ending applied to CSS (and its super languages) files.
+        :param line_ending: (experimental) The type of line ending applied to CSS (and its super languages) files. ``auto`` uses CRLF on Windows and LF on other platforms.
         :param line_width: (experimental) What's the max width of a line applied to CSS (and its super languages) files. Defaults to 80. Default: 80.
         :param quote_style: (experimental) The type of quotes used in CSS code. Defaults to double. Default: double.
 
@@ -785,6 +785,8 @@ class CssFormatterConfiguration:
     def line_ending(self) -> typing.Optional["LineEnding"]:
         '''(experimental) The type of line ending applied to CSS (and its super languages) files.
 
+        ``auto`` uses CRLF on Windows and LF on other platforms.
+
         :stability: experimental
         :schema: CssFormatterConfiguration#lineEnding
         '''
@@ -880,6 +882,7 @@ class CssLinterConfiguration:
     name_mapping={
         "allow_wrong_line_comments": "allowWrongLineComments",
         "css_modules": "cssModules",
+        "tailwind_directives": "tailwindDirectives",
     },
 )
 class CssParserConfiguration:
@@ -888,11 +891,13 @@ class CssParserConfiguration:
         *,
         allow_wrong_line_comments: typing.Optional[builtins.bool] = None,
         css_modules: typing.Optional[builtins.bool] = None,
+        tailwind_directives: typing.Optional[builtins.bool] = None,
     ) -> None:
         '''(experimental) Options that changes how the CSS parser behaves.
 
         :param allow_wrong_line_comments: (experimental) Allow comments to appear on incorrect lines in ``.css`` files.
         :param css_modules: (experimental) Enables parsing of CSS Modules specific features.
+        :param tailwind_directives: (experimental) Enables parsing of Tailwind CSS 4.0 directives and functions.
 
         :stability: experimental
         :schema: CssParserConfiguration
@@ -901,11 +906,14 @@ class CssParserConfiguration:
             type_hints = typing.get_type_hints(_typecheckingstub__8529582f37794a4d2a6c31671f27c3add8085e862adbf314c4f633b00295f518)
             check_type(argname="argument allow_wrong_line_comments", value=allow_wrong_line_comments, expected_type=type_hints["allow_wrong_line_comments"])
             check_type(argname="argument css_modules", value=css_modules, expected_type=type_hints["css_modules"])
+            check_type(argname="argument tailwind_directives", value=tailwind_directives, expected_type=type_hints["tailwind_directives"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
         if allow_wrong_line_comments is not None:
             self._values["allow_wrong_line_comments"] = allow_wrong_line_comments
         if css_modules is not None:
             self._values["css_modules"] = css_modules
+        if tailwind_directives is not None:
+            self._values["tailwind_directives"] = tailwind_directives
 
     @builtins.property
     def allow_wrong_line_comments(self) -> typing.Optional[builtins.bool]:
@@ -927,6 +935,16 @@ class CssParserConfiguration:
         result = self._values.get("css_modules")
         return typing.cast(typing.Optional[builtins.bool], result)
 
+    @builtins.property
+    def tailwind_directives(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Enables parsing of Tailwind CSS 4.0 directives and functions.
+
+        :stability: experimental
+        :schema: CssParserConfiguration#tailwindDirectives
+        '''
+        result = self._values.get("tailwind_directives")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -984,8 +1002,8 @@ class FilesConfiguration:
     ) -> None:
         '''(experimental) The configuration of the filesystem.
 
-        :param experimental_scanner_ignores: (experimental) Set of file and folder names that should be unconditionally ignored by Biome's scanner. Biome maintains an internal list of default ignore entries, which is based on user feedback and which may change in any release. This setting allows overriding this internal list completely. This is considered an advanced feature that users *should* not need to tweak themselves, but they can as a last resort. This setting can only be configured in root configurations, and is ignored in nested configs. Entries must be file or folder *names*. Specific paths and globs are not supported. Examples where this may be useful: ```jsonc { "files": { "experimentalScannerIgnores": [ // You almost certainly don't want to scan your ``.git`` // folder, which is why it's already ignored by default: ".git", // But the scanner does scan ``node_modules`` by default. If // you *really* don't want this, you can ignore it like // this: "node_modules", // But it's probably better to ignore a specific dependency. // For instance, one that happens to be particularly slow to // scan: "RedisCommander.d.ts", ], } } ``` Please be aware that rules relying on the module graph or type inference information may be negatively affected if dependencies of your project aren't (fully) scanned.
-        :param ignore_unknown: (experimental) Tells Biome to not emit diagnostics when handling files that doesn't know.
+        :param experimental_scanner_ignores: (experimental) **Deprecated:** Please use *force-ignore syntax* in ``files.includes`` instead: https://biomejs.dev/reference/configuration/#filesincludes. Set of file and folder names that should be unconditionally ignored by Biome's scanner.
+        :param ignore_unknown: (experimental) Tells Biome to not emit diagnostics when handling files that it doesn't know.
         :param includes: (experimental) A list of glob patterns. Biome will handle only those files/folders that will match these patterns.
         :param max_size: (experimental) The maximum allowed size for source code files in bytes. Files above this limit will be ignored for performance reasons. Defaults to 1 MiB Default: 1 MiB
 
@@ -1012,23 +1030,9 @@ class FilesConfiguration:
     def experimental_scanner_ignores(
         self,
     ) -> typing.Optional[typing.List[builtins.str]]:
-        '''(experimental) Set of file and folder names that should be unconditionally ignored by Biome's scanner.
-
-        Biome maintains an internal list of default ignore entries, which is based on user feedback and which may change in any release. This setting allows overriding this internal list completely.
-
-        This is considered an advanced feature that users *should* not need to tweak themselves, but they can as a last resort. This setting can only be configured in root configurations, and is ignored in nested configs.
+        '''(experimental) **Deprecated:** Please use *force-ignore syntax* in ``files.includes`` instead: https://biomejs.dev/reference/configuration/#filesincludes.
 
-        Entries must be file or folder *names*. Specific paths and globs are not supported.
-
-        Examples where this may be useful:
-
-        ```jsonc { "files": { "experimentalScannerIgnores": [ // You almost certainly don't want to scan your ``.git`` // folder, which is why it's already ignored by default: ".git",
-
-        // But the scanner does scan ``node_modules`` by default. If // you *really* don't want this, you can ignore it like // this: "node_modules",
-
-        // But it's probably better to ignore a specific dependency. // For instance, one that happens to be particularly slow to // scan: "RedisCommander.d.ts", ], } } ```
-
-        Please be aware that rules relying on the module graph or type inference information may be negatively affected if dependencies of your project aren't (fully) scanned.
+        Set of file and folder names that should be unconditionally ignored by Biome's scanner.
 
         :stability: experimental
         :schema: FilesConfiguration#experimentalScannerIgnores
@@ -1038,7 +1042,7 @@ class FilesConfiguration:
 
     @builtins.property
     def ignore_unknown(self) -> typing.Optional[builtins.bool]:
-        '''(experimental) Tells Biome to not emit diagnostics when handling files that doesn't know.
+        '''(experimental) Tells Biome to not emit diagnostics when handling files that it doesn't know.
 
         :stability: experimental
         :schema: FilesConfiguration#ignoreUnknown
@@ -1126,7 +1130,7 @@ class FormatterConfiguration:
         :param bracket_spacing: (experimental) Whether to insert spaces around brackets in object literals. Defaults to true. Default: true.
         :param enabled: 
         :param expand: (experimental) Whether to expand arrays and objects on multiple lines. When set to ``auto``, object literals are formatted on multiple lines if the first property has a newline, and array literals are formatted on a single line if it fits in the line. When set to ``always``, these literals are formatted on multiple lines, regardless of length of the list. When set to ``never``, these literals are formatted on a single line if it fits in the line. When formatting ``package.json``, Biome will use ``always`` unless configured otherwise. Defaults to "auto". Default: auto".
-        :param format_with_errors: (experimental) Stores whether formatting should be allowed to proceed if a given file has syntax errors.
+        :param format_with_errors: (experimental) Whether formatting should be allowed to proceed if a given file has syntax errors.
         :param includes: (experimental) A list of glob patterns. The formatter will include files/folders that will match these patterns.
         :param indent_style: (experimental) The indent style.
         :param indent_width: (experimental) The size of the indentation, 2 by default.
@@ -1240,7 +1244,7 @@ class FormatterConfiguration:
 
     @builtins.property
     def format_with_errors(self) -> typing.Optional[builtins.bool]:
-        '''(experimental) Stores whether formatting should be allowed to proceed if a given file has syntax errors.
+        '''(experimental) Whether formatting should be allowed to proceed if a given file has syntax errors.
 
         :stability: experimental
         :schema: FormatterConfiguration#formatWithErrors
@@ -1484,7 +1488,7 @@ class GraphqlFormatterConfiguration:
         :param enabled: (experimental) Control the formatter for GraphQL files.
         :param indent_style: (experimental) The indent style applied to GraphQL files.
         :param indent_width: (experimental) The size of the indentation applied to GraphQL files. Default to 2. Default: 2.
-        :param line_ending: (experimental) The type of line ending applied to GraphQL files.
+        :param line_ending: (experimental) The type of line ending applied to GraphQL files. ``auto`` uses CRLF on Windows and LF on other platforms.
         :param line_width: (experimental) What's the max width of a line applied to GraphQL files. Defaults to 80. Default: 80.
         :param quote_style: (experimental) The type of quotes used in GraphQL code. Defaults to double. Default: double.
 
@@ -1568,6 +1572,8 @@ class GraphqlFormatterConfiguration:
     def line_ending(self) -> typing.Optional["LineEnding"]:
         '''(experimental) The type of line ending applied to GraphQL files.
 
+        ``auto`` uses CRLF on Windows and LF on other platforms.
+
         :stability: experimental
         :schema: GraphqlFormatterConfiguration#lineEnding
         '''
@@ -1944,40 +1950,127 @@ class GritLinterConfiguration:
         )
 
 
+@jsii.data_type(
+    jsii_type="projen.javascript.biome_config.HtmlAssistConfiguration",
+    jsii_struct_bases=[],
+    name_mapping={"enabled": "enabled"},
+)
+class HtmlAssistConfiguration:
+    def __init__(self, *, enabled: typing.Optional[builtins.bool] = None) -> None:
+        '''(experimental) Options that changes how the HTML assist behaves.
+
+        :param enabled: (experimental) Control the assist for HTML (and its super languages) files.
+
+        :stability: experimental
+        :schema: HtmlAssistConfiguration
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__4f12d37d14edd5b34740aa842931963f60cd55f179c839350e2c9eb8d0ce519a)
+            check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if enabled is not None:
+            self._values["enabled"] = enabled
+
+    @builtins.property
+    def enabled(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Control the assist for HTML (and its super languages) files.
+
+        :stability: experimental
+        :schema: HtmlAssistConfiguration#enabled
+        '''
+        result = self._values.get("enabled")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "HtmlAssistConfiguration(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="projen.javascript.biome_config.HtmlConfiguration",
     jsii_struct_bases=[],
-    name_mapping={"formatter": "formatter", "parser": "parser"},
+    name_mapping={
+        "assist": "assist",
+        "experimental_full_support_enabled": "experimentalFullSupportEnabled",
+        "formatter": "formatter",
+        "linter": "linter",
+        "parser": "parser",
+    },
 )
 class HtmlConfiguration:
     def __init__(
         self,
         *,
+        assist: typing.Optional[typing.Union[HtmlAssistConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+        experimental_full_support_enabled: typing.Optional[builtins.bool] = None,
         formatter: typing.Optional[typing.Union["HtmlFormatterConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
+        linter: typing.Optional[typing.Union["HtmlLinterConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
         parser: typing.Optional[typing.Union["HtmlParserConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
         '''(experimental) Options applied to HTML files.
 
+        :param assist: 
+        :param experimental_full_support_enabled: (experimental) Enables full support for HTML, Vue, Svelte and Astro files.
         :param formatter: (experimental) HTML formatter options.
+        :param linter: (experimental) HTML linter options.
         :param parser: (experimental) HTML parsing options.
 
         :stability: experimental
         :schema: HtmlConfiguration
         '''
+        if isinstance(assist, dict):
+            assist = HtmlAssistConfiguration(**assist)
         if isinstance(formatter, dict):
             formatter = HtmlFormatterConfiguration(**formatter)
+        if isinstance(linter, dict):
+            linter = HtmlLinterConfiguration(**linter)
         if isinstance(parser, dict):
             parser = HtmlParserConfiguration(**parser)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__048266f3b4e4769e6485570d4954197f51204fc6e607e2ffe5267f80089b5ded)
+            check_type(argname="argument assist", value=assist, expected_type=type_hints["assist"])
+            check_type(argname="argument experimental_full_support_enabled", value=experimental_full_support_enabled, expected_type=type_hints["experimental_full_support_enabled"])
             check_type(argname="argument formatter", value=formatter, expected_type=type_hints["formatter"])
+            check_type(argname="argument linter", value=linter, expected_type=type_hints["linter"])
             check_type(argname="argument parser", value=parser, expected_type=type_hints["parser"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if assist is not None:
+            self._values["assist"] = assist
+        if experimental_full_support_enabled is not None:
+            self._values["experimental_full_support_enabled"] = experimental_full_support_enabled
         if formatter is not None:
             self._values["formatter"] = formatter
+        if linter is not None:
+            self._values["linter"] = linter
         if parser is not None:
             self._values["parser"] = parser
 
+    @builtins.property
+    def assist(self) -> typing.Optional[HtmlAssistConfiguration]:
+        '''
+        :stability: experimental
+        :schema: HtmlConfiguration#assist
+        '''
+        result = self._values.get("assist")
+        return typing.cast(typing.Optional[HtmlAssistConfiguration], result)
+
+    @builtins.property
+    def experimental_full_support_enabled(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Enables full support for HTML, Vue, Svelte and Astro files.
+
+        :stability: experimental
+        :schema: HtmlConfiguration#experimentalFullSupportEnabled
+        '''
+        result = self._values.get("experimental_full_support_enabled")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
     @builtins.property
     def formatter(self) -> typing.Optional["HtmlFormatterConfiguration"]:
         '''(experimental) HTML formatter options.
@@ -1988,6 +2081,16 @@ class HtmlConfiguration:
         result = self._values.get("formatter")
         return typing.cast(typing.Optional["HtmlFormatterConfiguration"], result)
 
+    @builtins.property
+    def linter(self) -> typing.Optional["HtmlLinterConfiguration"]:
+        '''(experimental) HTML linter options.
+
+        :stability: experimental
+        :schema: HtmlConfiguration#linter
+        '''
+        result = self._values.get("linter")
+        return typing.cast(typing.Optional["HtmlLinterConfiguration"], result)
+
     @builtins.property
     def parser(self) -> typing.Optional["HtmlParserConfiguration"]:
         '''(experimental) HTML parsing options.
@@ -2049,7 +2152,7 @@ class HtmlFormatterConfiguration:
         :param indent_script_and_style: (experimental) Whether to indent the ``<script>`` and ``<style>`` tags for HTML (and its super languages). Defaults to false. Default: false.
         :param indent_style: (experimental) The indent style applied to HTML (and its super languages) files.
         :param indent_width: (experimental) The size of the indentation applied to HTML (and its super languages) files. Default to 2. Default: 2.
-        :param line_ending: (experimental) The type of line ending applied to HTML (and its super languages) files.
+        :param line_ending: (experimental) The type of line ending applied to HTML (and its super languages) files. ``auto`` uses CRLF on Windows and LF on other platforms.
         :param line_width: (experimental) What's the max width of a line applied to HTML (and its super languages) files. Defaults to 80. Default: 80.
         :param self_close_void_elements: (experimental) Whether void elements should be self-closed. Defaults to never. Default: never.
         :param whitespace_sensitivity: (experimental) Whether to account for whitespace sensitivity when formatting HTML (and its super languages). Defaults to "css". Default: css".
@@ -2171,6 +2274,8 @@ class HtmlFormatterConfiguration:
     def line_ending(self) -> typing.Optional["LineEnding"]:
         '''(experimental) The type of line ending applied to HTML (and its super languages) files.
 
+        ``auto`` uses CRLF on Windows and LF on other platforms.
+
         :stability: experimental
         :schema: HtmlFormatterConfiguration#lineEnding
         '''
@@ -2231,6 +2336,49 @@ class HtmlFormatterConfiguration:
         )
 
 
+@jsii.data_type(
+    jsii_type="projen.javascript.biome_config.HtmlLinterConfiguration",
+    jsii_struct_bases=[],
+    name_mapping={"enabled": "enabled"},
+)
+class HtmlLinterConfiguration:
+    def __init__(self, *, enabled: typing.Optional[builtins.bool] = None) -> None:
+        '''(experimental) Options that changes how the HTML linter behaves.
+
+        :param enabled: (experimental) Control the linter for HTML (and its super languages) files.
+
+        :stability: experimental
+        :schema: HtmlLinterConfiguration
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__271da6fb8e26ef7e9c2ec0ea9fc3487d2975824399c15a87994edbcfcdd37131)
+            check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if enabled is not None:
+            self._values["enabled"] = enabled
+
+    @builtins.property
+    def enabled(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Control the linter for HTML (and its super languages) files.
+
+        :stability: experimental
+        :schema: HtmlLinterConfiguration#enabled
+        '''
+        result = self._values.get("enabled")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "HtmlLinterConfiguration(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="projen.javascript.biome_config.HtmlParserConfiguration",
     jsii_struct_bases=[],
@@ -2529,7 +2677,7 @@ class JsFormatterConfiguration:
         :param indent_style: (experimental) The indent style applied to JavaScript (and its super languages) files.
         :param indent_width: (experimental) The size of the indentation applied to JavaScript (and its super languages) files. Default to 2. Default: 2.
         :param jsx_quote_style: (experimental) The type of quotes used in JSX. Defaults to double. Default: double.
-        :param line_ending: (experimental) The type of line ending applied to JavaScript (and its super languages) files.
+        :param line_ending: (experimental) The type of line ending applied to JavaScript (and its super languages) files. ``auto`` uses CRLF on Windows and LF on other platforms.
         :param line_width: (experimental) What's the max width of a line applied to JavaScript (and its super languages) files. Defaults to 80. Default: 80.
         :param operator_linebreak: (experimental) When breaking binary expressions into multiple lines, whether to break them before or after the binary operator. Defaults to "after". Default: after".
         :param quote_properties: (experimental) When properties in objects are quoted. Defaults to asNeeded. Default: asNeeded.
@@ -2714,6 +2862,8 @@ class JsFormatterConfiguration:
     def line_ending(self) -> typing.Optional["LineEnding"]:
         '''(experimental) The type of line ending applied to JavaScript (and its super languages) files.
 
+        ``auto`` uses CRLF on Windows and LF on other platforms.
+
         :stability: experimental
         :schema: JsFormatterConfiguration#lineEnding
         '''
@@ -2953,7 +3103,7 @@ class JsParserConfiguration:
 )
 class JsonAssistConfiguration:
     def __init__(self, *, enabled: typing.Optional[builtins.bool] = None) -> None:
-        '''(experimental) Linter options specific to the JSON linter.
+        '''(experimental) Assist options specific to the JSON linter.
 
         :param enabled: (experimental) Control the assist for JSON (and its super languages) files.
 
@@ -3127,7 +3277,7 @@ class JsonFormatterConfiguration:
         :param expand: (experimental) Whether to expand arrays and objects on multiple lines. When set to ``auto``, object literals are formatted on multiple lines if the first property has a newline, and array literals are formatted on a single line if it fits in the line. When set to ``always``, these literals are formatted on multiple lines, regardless of length of the list. When set to ``never``, these literals are formatted on a single line if it fits in the line. When formatting ``package.json``, Biome will use ``always`` unless configured otherwise. Defaults to "auto". Default: auto".
         :param indent_style: (experimental) The indent style applied to JSON (and its super languages) files.
         :param indent_width: (experimental) The size of the indentation applied to JSON (and its super languages) files. Default to 2. Default: 2.
-        :param line_ending: (experimental) The type of line ending applied to JSON (and its super languages) files.
+        :param line_ending: (experimental) The type of line ending applied to JSON (and its super languages) files. ``auto`` uses CRLF on Windows and LF on other platforms.
         :param line_width: (experimental) What's the max width of a line applied to JSON (and its super languages) files. Defaults to 80. Default: 80.
         :param trailing_commas: (experimental) Print trailing commas wherever possible in multi-line comma-separated syntactic structures. Defaults to "none". Default: none".
 
@@ -3228,6 +3378,8 @@ class JsonFormatterConfiguration:
     def line_ending(self) -> typing.Optional["LineEnding"]:
         '''(experimental) The type of line ending applied to JSON (and its super languages) files.
 
+        ``auto`` uses CRLF on Windows and LF on other platforms.
+
         :stability: experimental
         :schema: JsonFormatterConfiguration#lineEnding
         '''
@@ -3424,6 +3576,11 @@ class LineEnding(enum.Enum):
 
     :stability: experimental
     '''
+    AUTO = "AUTO"
+    '''(experimental) auto.
+
+    :stability: experimental
+    '''
 
 
 @jsii.data_type(
@@ -4822,8 +4979,10 @@ __all__ = [
     "GritConfiguration",
     "GritFormatterConfiguration",
     "GritLinterConfiguration",
+    "HtmlAssistConfiguration",
     "HtmlConfiguration",
     "HtmlFormatterConfiguration",
+    "HtmlLinterConfiguration",
     "HtmlParserConfiguration",
     "IndentStyle",
     "JsAssistConfiguration",
@@ -4941,6 +5100,7 @@ def _typecheckingstub__8529582f37794a4d2a6c31671f27c3add8085e862adbf314c4f633b00
     *,
     allow_wrong_line_comments: typing.Optional[builtins.bool] = None,
     css_modules: typing.Optional[builtins.bool] = None,
+    tailwind_directives: typing.Optional[builtins.bool] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -5043,9 +5203,19 @@ def _typecheckingstub__4f328d623f0baa93f52695005ba45f28881c95ae610fde354116a44bc
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__4f12d37d14edd5b34740aa842931963f60cd55f179c839350e2c9eb8d0ce519a(
+    *,
+    enabled: typing.Optional[builtins.bool] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__048266f3b4e4769e6485570d4954197f51204fc6e607e2ffe5267f80089b5ded(
     *,
+    assist: typing.Optional[typing.Union[HtmlAssistConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    experimental_full_support_enabled: typing.Optional[builtins.bool] = None,
     formatter: typing.Optional[typing.Union[HtmlFormatterConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    linter: typing.Optional[typing.Union[HtmlLinterConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
     parser: typing.Optional[typing.Union[HtmlParserConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
 ) -> None:
     """Type checking stubs"""
@@ -5067,6 +5237,13 @@ def _typecheckingstub__bcbf243ebdc0f288a10a4e6b68dc5a1ff88f4d8abe5566f57f212bf10
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__271da6fb8e26ef7e9c2ec0ea9fc3487d2975824399c15a87994edbcfcdd37131(
+    *,
+    enabled: typing.Optional[builtins.bool] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__1b3cfca5c3ad8f608b86ade05d476530f16da0ba23410a7613236950da38ff37(
     *,
     interpolation: typing.Optional[builtins.bool] = None,

{projen-0.98.4.data → projen-0.98.5.data}/scripts/projen

@@ -8,7 +8,7 @@ if "JSII_RUNTIME_PACKAGE_CACHE" not in os.environ:
     os.environ["JSII_RUNTIME_PACKAGE_CACHE"] = "disabled"
 
 __jsii_assembly__ = jsii.JSIIAssembly.load(
-    "projen", "0.98.4", "projen", "projen@0.98.4.jsii.tgz"
+    "projen", "0.98.5", "projen", "projen@0.98.5.jsii.tgz"
 )
 
 exit_code = __jsii_assembly__.invokeBinScript("projen", "projen", sys.argv[1:])

{projen-0.98.4.dist-info → projen-0.98.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: projen
-Version: 0.98.4
+Version: 0.98.5
 Summary: CDK for software projects
 Home-page: https://github.com/projen/projen.git
 Author: Amazon Web Services

{projen-0.98.4.dist-info → projen-0.98.5.dist-info}/RECORD

@@ -1,7 +1,7 @@
-projen/__init__.py,sha256=-5-G0j3kUS_DA0HGLbfGUmpDPPAjHhbe3HeAfpAP_qE,684443
+projen/__init__.py,sha256=7d5Q78dZSFdo0MPHwc0EZ5n1ykM78LqYgGBlXvFueuU,703429
 projen/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-projen/_jsii/__init__.py,sha256=7RqZ2e_L8ydEiG1nExzo0iM7cRS_YYvV6feSaF-RV1Q,1404
-projen/_jsii/projen@0.98.4.jsii.tgz,sha256=9JVVOG5vrJhizUuxRN8ukmd1N2bEvKoTdr9MCO6ATkI,2954636
+projen/_jsii/__init__.py,sha256=UqlkGI_eDEEy9AvO2c9xQlEZx2_jvmALLeVXFhPbaQI,1404
+projen/_jsii/projen@0.98.5.jsii.tgz,sha256=FextoSpjhfwhmAztcp5QT7GPefUJZ5PUE3ilLr6v8pQ,2967311
 projen/awscdk/__init__.py,sha256=Y9PBCcy4WP1EFw243U6jnGHx3O4SIozJ50BJ1WBVldU,1157607
 projen/build/__init__.py,sha256=RZllpmDOwZ2McAIifVv2zr9oIrTEHhq-vXJEjzX2VkE,54258
 projen/cdk/__init__.py,sha256=-rKj5LNE96XVbKLV1OwO_jxjAeem6DAHjJLDdslmx9U,557823
@@ -13,15 +13,15 @@ projen/github/workflows/__init__.py,sha256=FvVHeCQ1lGQaMoXNsAQSOomS80eM5KO53JzEM
 projen/gitlab/__init__.py,sha256=NjkGjzgCYY3AZ1KnOTuwC8gfDfNjzYpeLICSvrU9EHs,208000
 projen/java/__init__.py,sha256=Y8yfXiL4RNXtxIc0LB7O3K0CKyw9TkQKkVXgJ57A9Fw,195299
 projen/javascript/__init__.py,sha256=E7UMkHJDO1u_-UlOkKz7f_Zx_I3HxpxgtO8JAunfVMk,902445
-projen/javascript/biome_config/__init__.py,sha256=_y9HJNQPgAYipQqK5UCNeS26bFvWS0nN3fWp6wTD9mo,224176
+projen/javascript/biome_config/__init__.py,sha256=cphNQ0EnQLrjXvQ-4b1s3yhJbkFCmpfuHupamcVARsI,230525
 projen/python/__init__.py,sha256=0VlKC2Qb-wiIW-Gi76uHJ-Uqb18c3GlIOtPsSmqe7EI,220713
 projen/release/__init__.py,sha256=-kYImxRw-uQRzzYwwxIrzUKcymPI4SPR2ui56VIBWow,339135
 projen/typescript/__init__.py,sha256=feogxGz8d-OTBl9O2PWJOkC5jkItBW8FLSoDp8Q2hpY,533562
 projen/vscode/__init__.py,sha256=gDvpsybrGDRr6b5owXoQ6-fS9sJlKiGr-jH6y8D985k,70199
 projen/web/__init__.py,sha256=fK7vIMzaHNYTpnrNo9piYjzp_HuEbYIzxXc_lgbLSSU,866566
-projen-0.98.4.data/scripts/projen,sha256=rvVKdDNZ0N6m4XBQ0l5oyn3MbsMj8cK4X6rktOxiGOo,356
-projen-0.98.4.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-projen-0.98.4.dist-info/METADATA,sha256=YYf-Ed8iI-fxKqRO_XqY2Ese9mF8K_l4MDTf5ZLsLZw,79609
-projen-0.98.4.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-projen-0.98.4.dist-info/top_level.txt,sha256=Ul8VGUArFqejE5BMSked3l6NMBO6gjQEWywhM5gw1zw,7
-projen-0.98.4.dist-info/RECORD,,
+projen-0.98.5.data/scripts/projen,sha256=jFxHdniojvL-BvSzxCg3BNfgSQ8RlNt1xZ98ZCk8RCg,356
+projen-0.98.5.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+projen-0.98.5.dist-info/METADATA,sha256=S3oTDhBsiIwl2obf6JVoyQn_M2DtZVZ2R62FqY1DEJc,79609
+projen-0.98.5.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+projen-0.98.5.dist-info/top_level.txt,sha256=Ul8VGUArFqejE5BMSked3l6NMBO6gjQEWywhM5gw1zw,7
+projen-0.98.5.dist-info/RECORD,,