public static int access_get_getMaxErrors(Task self) {
                    ${getDefaultDeprecation("Task", "maxErrors")}
                    return self.getMaxErrors().getOrElse(0);
                }

                public static void access_set_setMaxErrors(Task self, int arg0) {
                    ${getDefaultDeprecation("Task", "maxErrors")}
                    self.getMaxErrors().set(arg0);
                }
            }

        return self.modify(providerToDependency);
    }

    /**
     * Modifies a dependency.
     *
     * @param dependency dependency to modify
     * @return the modified dependency
     * @since 8.0
     */
    public static <D extends ModuleDependency> D call(DependencyModifier self, D dependency) {

    private final ClassLoaderSpec self;
    private final HierarchicalClassLoaderStructure parent;

    public HierarchicalClassLoaderStructure(ClassLoaderSpec self) {
        this(self, null);
    }

    public HierarchicalClassLoaderStructure(ClassLoaderSpec self, @Nullable HierarchicalClassLoaderStructure parent) {
        this.self = self;
        this.parent = parent;
    }

  namespace:
    var.query.new('namespace')
    + var.query.withDatasourceFromVariable(self.datasource)
    + var.query.queryTypes.withLabelValues(
      'namespace',
      'process_cpu_seconds_total{cluster=~"$%s"}' % self.cluster.name,
    )
    + var.query.withRefresh('time'),

  job:
    var.query.new('job')
    + var.query.withDatasourceFromVariable(self.datasource)
    + var.query.queryTypes.withLabelValues(
      'job',

                """
            ),
        ] = True,
    ):
        self.model = HTTPBaseModel(scheme="basic", description=description)
        self.scheme_name = scheme_name or self.__class__.__name__
        self.realm = realm
        self.auto_error = auto_error

    async def __call__(  # type: ignore
        self, request: Request
    ) -> Optional[HTTPBasicCredentials]:

                """
            ),
        ] = True,
    ):
        self.model: APIKey = APIKey(
            **{"in": APIKeyIn.query},  # type: ignore[arg-type]
            name=name,
            description=description,
        )
        self.scheme_name = scheme_name or self.__class__.__name__
        self.auto_error = auto_error

    async def __call__(self, request: Request) -> Optional[str]:

  def test_saved_model_to_stablehlo(self):
    with tempfile.TemporaryDirectory() as tempdir:
      path = build_savedmodel(tempdir)
      module_bytecode = tensorflow_to_stablehlo.savedmodel_to_stablehlo(
          input_path=path, input_arg_shapes_str='4'
      )
      with ir.Context() as ctx:
        stablehlo.register_dialect(ctx)
        module = ir.Module.parse(module_bytecode)

        val self = this
        return KaRendererKeywordFilter filter@{ modifier, kaAnnotated ->
            val analysisSession = this@filter
            self.filter(analysisSession, modifier, kaAnnotated) && other.filter(analysisSession, modifier, kaAnnotated)
        }
    }

    public infix fun or(other: KaRendererKeywordFilter): KaRendererKeywordFilter {
        val self = this

                - message: url must have schema one of [http, https, file, oci]
                  rule: 'isURL(self) ? (url(self).getScheme() in ['''', ''http'',
                    ''https'', ''oci'', ''file'']) : (isURL(''http://'' + self) &&
                    url(''http://'' +self).getScheme() in ['''', ''http'', ''https'',
                    ''oci'', ''file''])'
              verificationKey:

            ),
        ],
    ) -> None:
        self.debug = debug
        self.title = title
        self.summary = summary
        self.description = description
        self.version = version
        self.terms_of_service = terms_of_service
        self.contact = contact
        self.license_info = license_info
        self.openapi_url = openapi_url
        self.openapi_tags = openapi_tags